Question about delete/new

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

re: Question about delete/new

"pedicini" <scpedicini@nospam.yahoo.com> wrote...[color=blue]
>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)[/color]

No return type?
[color=blue]
> {
> 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?[/color]

(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.
[color=blue]
> 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?[/color]

Not if 'd' is NULL. If it's _uninitialised_, it contains garbage.
An attempt to 'delete[]' will cause undefined behaviour.
[color=blue]
>
> 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?[/color]

Pass 'd' by reference:

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

Victor

re: Question about delete/new

"pedicini" <scpedicini@nospam.yahoo.com> wrote in message
news:ckhq7a$47c$1@cronkite.cc.uga.edu...[color=blue]
>I work with many dynamically allocated variables in
> my program including double **, int *, char *.[/color]

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

re: Question about delete/new

"Victor Bazarov" <v.Abazarov@comAcast.net> wrote in message
news:0k0bd.117331$He1.23104@attbi_s01...[color=blue]
> "pedicini" <scpedicini@nospam.yahoo.com> wrote...[color=green]
> >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)[/color]
>
> No return type?[/color]

forgot, void clearDoubleArray
[color=blue]
>[color=green]
> > {
> > 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[/color][/color]
deal[color=blue][color=green]
> > 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[/color][/color]
should[color=blue][color=green]
> > I
> > keep track?[/color]
>
> (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.
>[color=green]
> > 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?[/color]
>
> Not if 'd' is NULL. If it's _uninitialised_, it contains garbage.
> An attempt to 'delete[]' will cause undefined behaviour.[/color]

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

[color=blue]
>[color=green]
> >
> > Also, I try to set d to NULL on the last statement of the function, but[/color][/color]
it[color=blue][color=green]
> > does not change
> > where d is pointing to. How can I fix that?[/color]
>
> Pass 'd' by reference:
>
> void clearDoubleArray(double ** &d, int rows)
> ...
>
> Victor
>
>[/color]

re: Question about delete/new

pedicini wrote:[color=blue]
> [...]
> so if I had:
>
> double **d;
> delete [] d;
>
> This would cause undefined behavior? is that right?[/color]

Yes.
[color=blue]
> But this is okay:
> double **d = NULL;
> delete [] d;[/color]

Yes.

V