delete and delete[]

Argh! I thought I knew this but I don't, and my book isn't helping either. Originally, I thought that delete is used to free an object created on the heap, while delete[] is used to free an array of objects created on the heap. But my book says that you use delete without the [] for that, so I'm really confused. What do you use delete[] for?? :confused:

I'm not a master at this, but I'm pretty certain you use delete[] for arrays. syntax is: delete[] (name of array);

Oh, nvm. The example in the book was:

Code:

---

char* temp;
temp = new char[256];
delete temp;

---

Maybe it's because temp was a char array. And we all know that those are special in a lot of ways :rolleyes:

I think you are right. The "delete" is used to release any storage that is allocated with "new", that is the object on the heap. The "delete []" is used to delete an arrary of objects on the heap.

Ok, thanks. It's good to know that I haven't screwed up my past 5 or so programs ;)

The rule of thumb is.. if you have used new with [], then you should use delete with [].

Quote:

---

char* temp;
temp = new char[256];
delete temp;

---

This should be:

Quote:

---

char* temp;
temp = new char[256];
delete [] temp;

---

I think the first example is flawed, it will only release part of the memory that was allocated.

what if you've got a situation like:

>> CSessionImage **image_vector;
>> image_vector = new CSessionImage *[num_ds];

so, a dynamically sized array of pointers to objects [in this case a CSessionImage object]....

calling:

>> delete [] image_vector;

in the local deconstructor, does not slip into the CSessionImage deconstructor as expected. and so does not free the memory allocated for the CSessionImage.

any ideas?

new [n] -> delete[]
new -> delete

If you do
char * p = new char[256];
delete p;
nothing bad will happen. This is because char is a primitive type (would work with int, float, etc.). Still it is bad practice.
The difference lies in objects. Only delete[] calls the destructors of EVERY object in the array, delete does it only for the first.

Code:

---

class cl {
public:
  cl() { cout << "Constructor" << endl; }
  ~cl() { cout << "Destructor" << endl; }
};

int main()
{
  cout << "1" << endl;
  cl * p = new cl[5];
  delete[] p;

  cout << "2" << endl;
  p = new cl[5];
  delete p;

  return 0;
}

---

Output:

Code:

---

1
Constructor
Constructor
Constructor
Constructor
Constructor
Destructor
Destructor
Destructor
Destructor
Destructor

2
Constructor
Constructor
Constructor
Constructor
Constructor
Destructor

---

unless your compiler has safeguards against that error.

Quote:

---

Originally posted by CornedBee

If you do
char * p = new char[256];
delete p;
nothing bad will happen. This is because char is a primitive type (would work with int, float, etc.).

---

No.[16.12] Can I drop the [] when deleteing array of some built-in type (char, int, etc)?

Never thought about that.

Global overloading of new...

Hmm, that sucks... I paid 90 bucks for this book too :(

Quote:

---

Originally posted by dug
what if you've got a situation like:

>> CSessionImage **image_vector;
>> image_vector = new CSessionImage *[num_ds];

so, a dynamically sized array of pointers to objects [in this case a CSessionImage object]....

calling:

>> delete [] image_vector;

in the local deconstructor, does not slip into the CSessionImage deconstructor as expected. and so does not free the memory allocated for the CSessionImage.

any ideas?

---

OK, you have an array of pointers. If you want to have deletion of the array delete the objects themselves, you need to explicitly delete the objects. For example, this line:

image_vector = new CSessionImage *[num_ds];

creates ZERO objects. It creates and allocates memory for POINTERS, but the pointers don't point to anything. Thus,

delete[] image_vector;

destroys zero objects; it only undoes the effect of the new[], which was to allocate memory for pointers. The pointers are deallocated here; any objects they point to are not. So depending on how you allocate objects to be pointed at, you need to use a corresponding means to deallocate the objects.

However, remember that the two worst things to use in C++ are dynamic arrays and pointers, so dynamic arrays OF pointers are even worse. The reason they are bad is that it's very easy to leak memory in these cases. And the C++ language provides better alternatives to dynamic arrays, and other libraries provide better alternatives to pointers.

Prefer STL containers like std::vector to an array. Prefer smart pointers like Boost's boost::shared_ptr, boost::weak_ptr, std::auto_ptr, etc. over normal pointers. Be SURE to use the correct type of pointer, though.

E.g., bad code:

Code:

---

int num_ds = 10;
CSessionImage **image_vector;
image_vector = new CSessionImage *[num_ds];
image_vector[0] = new CSessionImage(/*...*/);

// Now, we need to delete one object and deallocate the whole array:

delete image_vector[0];
delete[] image_vector;

---

This is bad; we explicitly have to delete the one object we created. A slightly better idea:

Code:

---

int num_ds = 10;
CSessionImage **image_vector;
image_vector = new CSessionImage *[num_ds];
for (int i = 0; i < num_ds; ++i)
  image_vector[i] = NULL;
image_vector[0] = new CSessionImage(/*...*/);

// Now, we need delete any objects that exist, and the array
// Deleting a pointer to NULL is a no-op by definition.

for (int i = 0; i < num_ds; ++i) delete image_vector[i];
delete[] image_vector;

---

However, this has problems. Say we did stuff in between:

Code:

---

int num_ds = 10;
CSessionImage **image_vector;
image_vector = new CSessionImage *[num_ds];
for (int i = 0; i < num_ds; ++i)
  image_vector[i] = NULL;
image_vector[0] = new CSessionImage(/*...*/);
/*
Other code here
*/
CSessionImage * temp = image_vector[0];

for (int i = 0; i < num_ds; ++i) delete image_vector[i];
delete[] image_vector;

/*
Other code here
*/

temp->Function();
// Crashes because we dereference a pointer that no longer exists

---

The above situation happens much more often than you might think. Especially consider the case where you create an object with a dynamic array of pointers like above, and then you make a method in its public interface that allows people to get or set pointers. In this case, it can be easy to delete a pointer before you're done with it. It is also easy to lose an object; if you assign a new pointer to an array member, you need to delete the old object or it can be lost forever (you will lose the only pointer to that object and thus can never delete it).

A much, much better idea:

Code:

---

int num_ds = 10;
typedef boost::shared_ptr<CSessionImage> CSI_ptr;
std::vector<CSI_ptr> image_vector(num_ds);
image_vector[0] = CSI_ptr(new CSessionImage(/*...*/));

---

As long as you are sure to create all CSessionImage objects like this:

CSI_ptr newPtr(new CSessionImage(/*...*/));

newPtr will work (almost) just like a CSessionImage pointer; to call CSessionImage::FunctionA():

newPtr->FunctionA();

etc.

The best part? No deletes, anywhere. The vector will deallocate when it's out of scope, the pointers will destroy the object within once the last shared_ptr to that object is gone. Just a simple wrapper around every call to new guarantees you never need to worry about deletion. As long as you have a shared_ptr that is not NULL, you have a valid object pointer; the object cannot have been deleted. If you assign to the vector, and the only existing shared pointer is gone, then the object is deleted. This method solves (almost all) problems related to not being able to free memory. In fact, as long as there are no cycles of pointers (e.g., say A has a pointer to B which has a pointer to C which has a pointer to A) you cannot leak memory with boost::shared_ptr. If you need cycles, read about boost::weak_ptr.

In general:

* Use std::vector instead of dynamic arrays of all non-character objects.
* Use std::string or std::wstring for all strings.
* Use smart pointers instead of normal pointers. NEVER use auto_ptr within a container, though.

delete and delete[] both can be used to free up dynamically allocated array.

The difference is : if the array is an array of object, delete will execute only first element's destructor while delete[] will execute destructor of all the array elements.

>>delete and delete[] both can be used to free up dynamically allocated array.
Wrong,read the whole thread,or this
[16.11] What if I forget the [] when deleteing array allocated via new T[n]?