C++ Using delete on 2D-Vector of a struct with float arrays

I have a struct like this:

struct foo {

  int a,b,c;

  float d; 

  float *array1;

  float *array;

}; 

And now I us开发者_JAVA百科e this struct for a 8x8 2D-Vector like this:

vector< vector<foo> > bar(8);
for (int i = 0; i < 8; i++)
    bar[i].resize(8);

Within my program, "bar" is now filled with data, for example:

bar[1][5].array1 = new float[256];
bar[1][5].array2 = new float[256];
// Et cetera.

How can I free the memory used by bar correctly?

I tried a for-loop for freeing every float array like this:

delete [] bar[i][j].array1;

But that will result in a heap exception on runtime.

Add a destructor to your struct to clean up those members.

Alternatively you could do as Eduardo León suggests and allocate them as part of the structure.

float array1[256];

instead of

float *array1;

First of all, you ought to use vector<float> instead of float*, arrays are evil.

Second, the way you are freeing the memory is correct, the mistake must be at some other place.

Can you post an actual code fragment? If you're deleting just the elements you're allocating, there shouldn't be a problem.

I'd suggest a couple things to help narrow it down:

1. Assign NULL to all your pointers on initialization
2. Use shared_ptr types instead of raw float pointers - these will be automatically cleaned up when no references remain.

I suggest you use an vector or other stl-container, which fits your need.

If it has to be arrays - better use an destructor in your struct, so you need not to think about manually cleanup:

  struct foo
  {
    int a,b,c;
    float d; 
    float *array1;
    float *array2;

     foo ()
        : a(0),
        b(0),
        c(0),
        d(0.0),
        array1(NULL),
        array2(NULL)
     { }

     ~foo ()
     {
        delete [] array1;
        delete [] array2;
     }
  }; 

edit: removed check of NULL on delete []

This easiest way to accomplish this would be to create a constructor and destructor:

struct foo {

  int a,b,c;
  float d; 
  float *array1;
  float *array;

  foo()
  {
    array1 = array = 0;
  }

  ~foo()
  {
    delete [] array1;
    delete [] array;
  }

};

Even better would be members to track the size of array1 & array so that a copy constructor and/or assignment operator could clone them as needed.

Note: by "easiest" I do not mean "best". :)

You have to add this destructor to your struct foo:

~foo() {
  delete []array1;
  delete []array2;
}

I suggest also to create a constructor for you foo that initializes those two pointers to 0:

foo()
:a(0),b(0),c(0),
 d(0.0), array1(0), array2(0)
{}