Question about delete/new

[pedicini]

I work with many dynamically allocated variables in
my program including double **, int *, char *.

For ex:

double **d;
d = new (double *) [10];
for(int i = 0; i < 10; i++) {
d[i] = new double[10];
}

to setup a 2d array of doubles.

My memory clear function looks like this:

clearDoubleArray(double **d, int rows)
{
for(int i = 0; i < rows; i++) {
delete [] d[i];
}

delete [] d;

d = NULL;
}

In my program, the same variable is allocated and deallocated a great deal
of times.
Sometimes I'm not sure whether d has been initialized, or has been deleted.
Is it safe
to call clearDoubleArray() on a var that has not been allocated? Or should I
keep track?
Just for the sake of argument, assume that whenever d has not been
allocated, that rows = 0,
so it does not use the delete[] d[i] loop shown above.

Will delete[] d cause problems?

Also, I try to set d to NULL on the last statement of the function, but it
does not change
where d is pointing to. How can I fix that?

Thanks
Shaun

[Victor Bazarov]

"pedicini" <sc********@nospam.yahoo.com> wrote...

I work with many dynamically allocated variables in
my program including double **, int *, char *.

For ex:

double **d;
d = new (double *) [10];
for(int i = 0; i < 10; i++) {
d[i] = new double[10];
}

to setup a 2d array of doubles.

My memory clear function looks like this:

clearDoubleArray(double **d, int rows)
No return type?
{
for(int i = 0; i < rows; i++) {
delete [] d[i];
}

delete [] d;

d = NULL;
}

In my program, the same variable is allocated and deallocated a great deal
of times.
Sometimes I'm not sure whether d has been initialized, or has been
deleted.
Is it safe
to call clearDoubleArray() on a var that has not been allocated? Or should
I
keep track?
(a) You should keep track at least to know what 'rows' to pass in.
(b) If 'd' is NULL, delete or delete[] will be OK, but an attempt to
dereference it to get d[i] is going to fail.
(c) Every time you deallocate I recommend setting it to NULL.
Just for the sake of argument, assume that whenever d has not been
allocated, that rows = 0,
so it does not use the delete[] d[i] loop shown above.

Will delete[] d cause problems?
Not if 'd' is NULL. If it's _uninitialised_, it contains garbage.
An attempt to 'delete[]' will cause undefined behaviour.

Also, I try to set d to NULL on the last statement of the function, but it
does not change
where d is pointing to. How can I fix that?

Pass 'd' by reference:

void clearDoubleArray(double ** &d, int rows)
...

Victor

[Chris]

"pedicini" <sc********@nospam.yahoo.com> wrote in message
news:ck**********@cronkite.cc.uga.edu...

I work with many dynamically allocated variables in
my program including double **, int *, char *.

try let the STL do the work for you:

typedef std::vector< double > tDoubleVector;
typedef std::vector< tDoubleVector > t2D_DoubleVector;

typedef std::auto_ptr< int > tIntPtr;

etc.........
-c

[pedicini]

"Victor Bazarov" <v.********@comAcast.net> wrote in message
news:0k0bd.117331$He1.23104@attbi_s01...

"pedicini" <sc********@nospam.yahoo.com> wrote...

I work with many dynamically allocated variables in
my program including double **, int *, char *.

For ex:

double **d;
d = new (double *) [10];
for(int i = 0; i < 10; i++) {
d[i] = new double[10];
}

to setup a 2d array of doubles.

My memory clear function looks like this:

clearDoubleArray(double **d, int rows)
No return type?

forgot, void clearDoubleArray

{
for(int i = 0; i < rows; i++) {
delete [] d[i];
}

delete [] d;

d = NULL;
}

In my program, the same variable is allocated and deallocated a great deal of times.
Sometimes I'm not sure whether d has been initialized, or has been
deleted.
Is it safe
to call clearDoubleArray() on a var that has not been allocated? Or should I
keep track?
(a) You should keep track at least to know what 'rows' to pass in.
(b) If 'd' is NULL, delete or delete[] will be OK, but an attempt to
dereference it to get d[i] is going to fail.
(c) Every time you deallocate I recommend setting it to NULL.

Just for the sake of argument, assume that whenever d has not been
allocated, that rows = 0,
so it does not use the delete[] d[i] loop shown above.

Will delete[] d cause problems?

Not if 'd' is NULL. If it's _uninitialised_, it contains garbage.
An attempt to 'delete[]' will cause undefined behaviour.

so if I had:

double **d;
delete [] d;

This would cause undefined behavior? is that right?
But this is okay:
double **d = NULL;
delete [] d;

Thanks for your help Victor,
Shaun

Also, I try to set d to NULL on the last statement of the function, but it does not change
where d is pointing to. How can I fix that?

Pass 'd' by reference:

void clearDoubleArray(double ** &d, int rows)
...

Victor

[Victor Bazarov]

pedicini wrote:

[...]
so if I had:

double **d;
delete [] d;

This would cause undefined behavior? is that right?
Yes.
But this is okay:
double **d = NULL;
delete [] d;

Yes.

V