memory allocation.

[siddhu]

If i create array of int* on heap in the following way
{
int ** i = new int*[2];
int j = 0;
i[0]=&j;
i[1]=&j;
delete []i;
}

My question is, does the above code has any memory leak?

And if i do it in following way

{
int ** i = new int*[2];
int j = 0;
i[0]=new int(j);
i[1]=new int(j);
delete []i;
return 0;
}

Does "delete []i;" take care of everything?
Or should I do
delete i[0];delete i[1]; before i do delete []i; to avoid memory leak.

[Greg]

siddhu wrote:

If i create array of int* on heap in the following way
{
int ** i = new int*[2];
int j = 0;
i[0]=&j;
i[1]=&j;
delete []i;
}

My question is, does the above code has any memory leak?
No, because each new is matched with a corresponding delete.
And if i do it in following way

{
int ** i = new int*[2];
int j = 0;
i[0]=new int(j);
i[1]=new int(j);
delete []i;
return 0;
}

Does "delete []i;" take care of everything?
Or should I do
delete i[0];delete i[1]; before i do delete []i; to avoid memory leak.

With three new's and only one delete, there is a memory leak since two
of the new's have no corresponding delete's.

This being a C++ newsgroup, just toss everything into a std::vector.
Then you will not have to worry about matching calls to new with
subsequent calls to delete.

Greg

[Gianni Mariani]

siddhu wrote:

If i create array of int* on heap in the following way
{
int ** i = new int*[2];
int j = 0;
i[0]=&j;
i[1]=&j;
delete []i;
}

My question is, does the above code has any memory leak?
one "new" ... one "delete" - no leak.

And if i do it in following way

{
int ** i = new int*[2];
int j = 0;
i[0]=new int(j);
i[1]=new int(j);
delete []i;
return 0;
}

Does "delete []i;" take care of everything?
3 x "new" ... 1 x "delete" - yep, there 2 memory leaks.
Or should I do
delete i[0];delete i[1]; before i do delete []i; to avoid memory leak.

In general, you need to pair new with delete until you start using smart
pointers.

e.g.

#include <memory>

int main()
{
std::auto_ptr<int> * i = new std::auto_ptr<int>[2];
int j = 0;
i[0].reset( new int(j) );
i[1].reset( new int(j) );
delete []i;
return 0;
}

[Maxim Yegorushkin]

Gianni Mariani wrote:

[]

In general, you need to pair new with delete until you start using smart
pointers.

e.g.

#include <memory>

int main()
{
std::auto_ptr<int> * i = new std::auto_ptr<int>[2];
int j = 0;
i[0].reset( new int(j) );
i[1].reset( new int(j) );
delete []i;
return 0;
}

Bad example. This code is not exception safe. If any of new int()
throws i will leak.

[swesoc]

siddhu wrote:

If i create array of int* on heap in the following way {
int ** i = new int*[2];
int j = 0;
i[0]=&j;
i[1]=&j;
delete []i;
}
My question is, does the above code has any memory leak?

Here there are 2 pointers pointing to the same memory, now delete []i
will delete the 1st pointer while deleting the 2nd pointer, there will
be problem as that memory is already deleted result in a dangling
pointer.

And if i do it in following way
{
int ** i = new int*[2];
int j = 0;
i[0]=new int(j);
i[1]=new int(j);
delete []i;
return 0;

}
Does "delete []i;" take care of everything?
Or should I do
delete i[0];delete i[1]; before i do delete []i; to avoid memory leak.

Over here there will be no problem of neither memory leak or dangling
pointer

[bvatsa]

There is no problemwith the both code snippets, delete []i ,, will take
care of everything..