passing new object to function c++

Question

I just want to know if this is a bad practice to do.

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

The new car() object should live after calling it from happyFunction and later it should be destroyed . Now is that ok to do. I mean shouldn't I delete the memory allocated for that instance?

Example to make it more clear.

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

Is this a good practice to do? Should I delete the memory allocation? I hope my question is clear. thank you.

Answer 1

happyFunction(new Car()); 

It's not bad practice in itsself (although almost certainly is wrong), the memory could be deleted inside the function. But that would be confusing so it's really not the best idea.

Also although it's safe with one parameter, if it was like this

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

And one of the news threw an exception after the other new executed, the would be no way to free the memory so it's not safe.

You always have to free memory yourself in c++ so your second example leads to a big memory leak. There are classes such as unique_ptr and shared_ptr to help you manage it without having to write a delete yourself, you can find any number of tutorials online about them

Answer 2

There are two possibilities:

1. happyFunction is supposed to take ownership of the pointer, and the caller never worries about it. In this case, it would be more sensible to write

   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 is only supposed to use the pointer: the caller retains control and ownership. In this case, it would be better to pass a reference so there is no suggestion that ownership is transferred

   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
   }
   

Answer 3

Caller can retain ownership of the pointer to new Car() if your happyFunction() returns pointer to that memory created by new Car().

Consider following code:

#include <string>
#include <iostream>

using std::string;
using std::cout;

class Car
{
public:
    string s;
    Car(string str):s(str) {}
};

Car* happyFunction(Car *pCar)
{
    // do something with data pointed to by pCar
    return pCar;
};

int main()
{
    // outer pointer to memory allocated by new operator
    Car *pCar = happyFunction(new Car("test"));
    // pCar still points to valid object even after happyFunction() content
    // went out of scope
    cout << pCar->s << "\n";

    // release pCar memory outside the happyFunction()
    delete pCar;

    return 0;
}