传递新对象到函数C++

Question

只是想知道这是否是一个不好的做法。

for(int i=0;i<1000;i++) 
    happyFunction(new Car()); 

新车（）对象的生活应当不受happyFunction调用它后，以后应该摧毁 现在是确定的事情。我的意思是我不应该删除为该实例分配的内存？

示例使其更加清晰。

int i = 0; 
for (i=0;i<1000;i++){ 
new car(); 
} 

这是一个很好的做法吗？我应该删除内存分配吗？ 我希望我的问题很清楚。 谢谢。

Answer 1

happyFunction(new Car()); 

在自己的实践中（虽然几乎肯定是错误的），内存可以在函数内部删除。但那会让人困惑，所以它不是最好的主意。

而且虽然它是安全的一个参数，如果是这样的

happyFunction(new Car(), new Thing()); 

和消息一个接着抛出异常其他新执行时，就没有办法来释放内存，所以它不是安全。

你总是不得不自己用C++释放内存，所以你的第二个例子会导致大的内存泄漏。有类如的unique_ptr和shared_ptr的来帮助你管理它，而无需编写自己删除，你可以找到任何数量的教程在网上对他们

Answer 2

有两种可能性：

1. happyFunction应该取得指针的所有权，并且调用者从不担心它。在这种情况下，这将是更明智写

   void happyFunction(std::unique_ptr<Car> &&car) 
   { 
       // car is mine now, and is automatically destroyed when I return 
       // unless I explicitly request otherwise 
   } 
   
   void caller() 
   { 
       happyFunction(std::unique_ptr<Car>(new Car)); 
       // the new Car is immediately handed over to the unique_ptr 
       // and I don't have to worry about leaks 
   } 
   

2. happyFunction情况应该只是一个使用指针：主叫方保留控制和所有权。在这种情况下，这将是更好地传递一个参考，所以没有建议，所有权转移

   void happyFunction(Car &car) 
   { 
       // car is still owned by the caller, 
       // I just get a reference to use in here 
   } 
   
   void automatic_caller() 
   { 
       Car car; 
       happyFunction(car); 
       // car is always owned by me, and is 
       // automatically destroyed at the end of this scope 
   } 
   
   // alternatively (only if car should live longer than the enclosing scope) 
   void dynamic_caller() 
   { 
       std::unique_ptr<Car> car(new Car); 
       // or get pointer from somewhere else ... 
       // or get shared_pointer, etc. etc. 
       happyFunction(*car); 
       // again car is destroyed here unless we do something special 
   }