Question about delete[]

[Randy Gordon]

Say I do the following:

char **names = new char*[100];
for (int i = 0; i < 100; i++) {
names[i] = new char[5];
}

When I'm done with the array of character pointers, how should I delete it?
Like this:

for (int i = 0; i < 100; i++) {
delete names[i];
}
delete[] names;

or like this:

delete[] names;

Basically, does delete[] call each individual delete or not? If so, what
happens if I do the former method? Assuming it doesn't, then I guess the
second method would create a memory leak.

[Moonlit]

"Randy Gordon" <no****@forme.com> wrote in message
news:3_****************@newssvr13.news.prodigy.com ...

Say I do the following:

char **names = new char*[100];
for (int i = 0; i < 100; i++) {
names[i] = new char[5];
}

When I'm done with the array of character pointers, how should I delete it? Like this:

for (int i = 0; i < 100; i++) {
delete names[i];
}
delete[] names;

or like this:

delete[] names;
Both. You allocated the array of pointers and then an array of characters in
the loop. So you have to delete those arrays too.

Basically, does delete[] call each individual delete or not? If so, what No. happens if I do the former method? Assuming it doesn't, then I guess the
second method would create a memory leak.
If you leave one delete out you create a memory leak. For every new there
has to be a corresponding delete.

Regards, Ron AF Greve

[Gianni Mariani]

Randy Gordon wrote:

Say I do the following:

char **names = new char*[100];
for (int i = 0; i < 100; i++) {
names[i] = new char[5];
}

When I'm done with the array of character pointers, how should I delete it?
Like this:

for (int i = 0; i < 100; i++) {
delete names[i];
}
delete[] names;

or like this:

delete[] names;

Basically, does delete[] call each individual delete or not?
No - it does not. The basic idea is that if you call new, you're
probably goint to need to call delete.

If so, what happens if I do the former method? Assuming it doesn't, then I guess the
second method would create a memory leak.

Yes - it leaks.

You can use a "smart pointer" class that does the delete for you.

G

[Thomas J. Clancy]

"Randy Gordon" <no****@forme.com> wrote in message
news:3_****************@newssvr13.news.prodigy.com ...

Say I do the following:

char **names = new char*[100];
for (int i = 0; i < 100; i++) {
names[i] = new char[5];
}

When I'm done with the array of character pointers, how should I delete it? Like this:

for (int i = 0; i < 100; i++) {
delete names[i];
}
delete[] names;

Simple rule of thumb... delete what you create (new) unless you're using
smart pointers or auto pointers.

tom


---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (http://www.grisoft.com).
Version: 6.0.537 / Virus Database: 332 - Release Date: 11/6/2003

[Randy Gordon]

> Both. You allocated the array of pointers and then an array of characters
in

the loop. So you have to delete those arrays too.

Basically, does delete[] call each individual delete or not? If so, what

No.

happens if I do the former method? Assuming it doesn't, then I guess the
second method would create a memory leak.

If you leave one delete out you create a memory leak. For every new there
has to be a corresponding delete.

Regards, Ron AF Greve

All right, that makes sense. Now that I think about, why is the following
correct:

for (int i = 0; i < 100; i++) {
delete names[i];
}

and not this:

for (int i = 0; i < 100; i++) {
delete[] names[i];
}

I mean, it's an array of characters I'm trying to free right? So shouldn't I
use delete[] instead of delete?

[Max M.]

Randy Gordon wrote:

All right, that makes sense. Now that I think about, why is the following
correct:

for (int i = 0; i < 100; i++) {
delete names[i];
}

and not this:

for (int i = 0; i < 100; i++) {
delete[] names[i];
}

In fact, the latter is correct; the former is not.

I mean, it's an array of characters I'm trying to free right? So shouldn't
I use delete[] instead of delete?

You should. You must, actually.

Max

[lilburne]

Randy Gordon wrote:

All right, that makes sense. Now that I think about, why is the following
correct:

for (int i = 0; i < 100; i++) {
delete names[i];
}

and not this:

for (int i = 0; i < 100; i++) {
delete[] names[i];
}

I mean, it's an array of characters I'm trying to free right? So shouldn't I
use delete[] instead of delete?

Yes the second version 'delete[] names[i];' is the correct
version to use if you are deleting an array, because it
calls the destructor for each element in the array. However,
a lot of people use 'delete names[i];' when the elements are
PODs like char, but it is not correct.

[Peter van Merkerk]

> Say I do the following:

char **names = new char*[100];
for (int i = 0; i < 100; i++) {
names[i] = new char[5];
}

When I'm done with the array of character pointers, how should I delete it? Like this:

for (int i = 0; i < 100; i++) {
delete names[i];
}
delete[] names;

or like this:

delete[] names;

Basically, does delete[] call each individual delete or not? If so, what happens if I do the former method? Assuming it doesn't, then I guess the second method would create a memory leak.

Others have already answered your question. But I think you should know
that your code will become a lot simpler and safer when you replace the
C style arrays with the C++ classes std::vector and st::string. The code
you posted for allocating and deallocating a collection of names could
be reduced to:

std::vector<std::string> names(100);

Not only is this code shorter, but both std::vector and std::string can
(easilly) dynamically grow to accommodate more names and/or longer names
(i.e. no arbitrary length limitation). When the names object runs out of
scope (e.g. because of function return or exception) all memory
allocated on its behalf will automatically be freed. If you have to
delete the memory manually like in the code you posted, it can be rather
tricky not to leak memory when an exception occures.

--
Peter van Merkerk
peter.van.merkerk(at)dse.nl

[Stuart Golodetz]

"Randy Gordon" <no****@forme.com> wrote in message
news:3_****************@newssvr13.news.prodigy.com ...

Say I do the following:

char **names = new char*[100];
for (int i = 0; i < 100; i++) {
names[i] = new char[5];
}

When I'm done with the array of character pointers, how should I delete it? Like this:

for (int i = 0; i < 100; i++) {
delete names[i];
}
delete[] names;
for (int i=0; i<100; ++i)
{
delete [] names[i]; // note: delete [], *not* delete
}
delete [] names;

HTH,

Stuart.
or like this:

delete[] names;

Basically, does delete[] call each individual delete or not? If so, what
happens if I do the former method? Assuming it doesn't, then I guess the
second method would create a memory leak.