When to use "new" and when not to, in C++?

Frankenstein picture Frankenstein · Mar 24, 2009 · Viewed 119.7k times · Source

Possible Duplicate:
When should I use the new keyword in C++?

When should I use the "new" operator in C++? I'm coming from C#/Java background and instantiating objects is confusing for me.

If I've created a simple class called "Point", when I create a point should I:

Point p1 = Point(0,0);

or

Point* p1 = new Point(0, 0);

Can someone clarify for me when to use the new operator and when not to?

Duplicate of:

When should I use the new keyword in C++?

Related:

About constructors/destructors and new/delete operators in C++ for custom objects

Proper stack and heap usage in C++?

Answer

Andrew Grant picture Andrew Grant · Mar 24, 2009

You should use new when you wish an object to remain in existence until you delete it. If you do not use new then the object will be destroyed when it goes out of scope. Some examples of this are:

void foo()
{
  Point p = Point(0,0);
} // p is now destroyed.

for (...)
{
  Point p = Point(0,0);
} // p is destroyed after each loop

Some people will say that the use of new decides whether your object is on the heap or the stack, but that is only true of variables declared within functions.

In the example below the location of 'p' will be where its containing object, Foo, is allocated. I prefer to call this 'in-place' allocation.

class Foo
{

  Point p;
}; // p will be automatically destroyed when foo is.

Allocating (and freeing) objects with the use of new is far more expensive than if they are allocated in-place so its use should be restricted to where necessary.

A second example of when to allocate via new is for arrays. You cannot* change the size of an in-place or stack array at run-time so where you need an array of undetermined size it must be allocated via new.

E.g.

void foo(int size)
{
   Point* pointArray = new Point[size];
   ...
   delete [] pointArray;
}

(*pre-emptive nitpicking - yes, there are extensions that allow variable sized stack allocations).