Deallocation of 3 dimensional array

Question

I am creating a three dimensional array like this:

GLfloat ***tgrid;
//other code in between here
tgrid = new GLfloat**[nx];
for(int i = 0; i < nx; i++)
{
    tgrid[i] = new GLfloat*[ny];
    for(int j = 0; j < ny; j++)
    {
        tgrid[i][j] = new GLfloat[nz];
    }
}

Does this mean i should deallocate the memory like this:

for(int i = 0; i < nx; i++)
{
    for(int j = 0; j < ny; j++)
    {
        delete [] tgrid[i][j];
    }
    delete [] tgrid[i];
}
delete [] tgrid;

?

I know that they are supposed to go in "reverse" order but I'm not sure I'm doing it right ... Does this seem correct?

Looks correct but surely not recommended. You can easily do this with a flat array, the size in each dimension and a simple indexing scheme. This is really what most organizations/companies/societies do when handling multi-dimensional data, e.g. OpenGL. — ksming, Sep 16 '11 at 04:02
Heck you can do it with a *real* 3D array. [Various possibilities (in c99, but the options are closely parallel).](http://stackoverflow.com/q/7424769/2509) — dmckee --- ex-moderator kitten, Sep 16 '11 at 05:08

ksming · Accepted Answer · 2011-09-16T05:10:55.887

3

Since my answer is also yes, I will follow up K-ballo's answer with a minimal example of how to use a flat array to store a set of multi-dimension data:

Store the GLfloat pointer and the dimensions as members of your class:

GLfloat *tgrid;
int nx, ny, nz;

In initlaization function:

void CreateGrid(int x, int y, int z)
{
    nx = x;
    ny = y;
    nz = z;
    tgrid = new GLfloat[nx*ny*nz];
}

You will need to define your indexing scheme consistently for proper read-write:

GLfloat GetValueAt(int x, int y, int z)
{

    return tgrid[ (nx*ny*z) + (nx*y) + x ]; 

}

void SetValueAt(int x, int y, int z, GLfloat value)
{

    tgrid[ (nx*ny*z) + (nx*y) + x ] = value;

}

Deleting is straight forward too since tgrid is only a flat array.

edited Sep 16 '11 at 05:10

answered Sep 16 '11 at 04:17

ksming

1,422
1
16
26

Note also the performance benefits in having a single pair of `new/delete` calls. There may likely be further performance benefits through using a contigous block rather than a potentially scattered collection of small blocks. – Keith Sep 16 '11 at 05:00
i thought about doing this actually. which would benefit more from locality of reference more? – drjrm3 Sep 16 '11 at 14:55

score 2 · Answer 2 · answered Sep 16 '11 at 03:52

2

Yes. (What else am I meant to say)

answered Sep 16 '11 at 03:52

flight

7,162
4
24
31

score 1 · Answer 3 · answered Sep 16 '11 at 03:52

Yes, you have to deallocate them in reverse order. Otherwise you will loose the inner pointers before deallocating them.

Is there any reason why you cannot use a flat array to represent your 3dimensional array? Perhaps Boost.MultiArray, which handles multiple dimensions and allows access to the underlying (flat) array?

score 0 · Answer 4 · answered Sep 16 '11 at 04:44

Or, you could use std::vector and not worry about new or delete:

std::vector<std::vector<std::vector<GLfloat> > > tgrid;
tgrid.resize(nx);
for(int i = 0; i < nx; i++) {
  tgrid[i].resize(ny);
  for(int j = 0; j < ny; i++) {
    tgrid[i][j].resize(nz);
  }
}

score 0 · Answer 5 · answered Sep 16 '11 at 10:23

0

Also you can implement a wrapper class for std::vector

answered Sep 16 '11 at 10:23

fasked

3,555
1
19
36

Deallocation of 3 dimensional array

5 Answers5

Linked