how to delete a 3-d array?

[bigtrace]

I create a class template to help me build a 3-d array.
but I got "heap corruption detected after normal block #165 c++"
during the class destructor when I try to deallocate the memory.

thanks for any advice.

  #include <iostream>
using namespace std;




template <class T>
	class CArray3D {

	private:

		T*** p3DArray;

		int a_;
		int b_;
		int c_;

	public:

		CArray3D(int a, int b, int c):a_(a),b_(b),c_(b) {

			p3DArray = new T**[a_];

			for (int i = 0; i < a_; i++) {

				
				p3DArray[i] = new T*[b_];

				for (int j = 0; j < b_; j++) {


						p3DArray[i][j] = new T[c_];


				}


			}



		}



		T** operator[](int a) {

			return p3DArray[a];
		}




		~CArray3D() {

			for (int i = 0; i < a_; i++) {

				for (int j = 0; j < b_; j++) {

					delete[] p3DArray[i][j];
					
				}
				
				delete[] p3DArray[i];
			}

			delete[] p3DArray;
		}



	};




int main()
{
	CArray3D<int> a(3, 4, 5);
	int No = 0;
	for (int i = 0; i < 3; ++i)
		for (int j = 0; j < 4; ++j)
			for (int k = 0; k < 5; ++k)
				a[i][j][k] = No++;
	for (int i = 0; i < 3; ++i)
		for (int j = 0; j < 4; ++j)
			for (int k = 0; k < 5; ++k)
				cout << a[i][j][k] << ",";
	return 0;
}

[helios]

Suggestion #1: Don't use an [array of pointers to arrays of pointers to arrays] to begin with. Just use a single array.

int width = /*...*/;
int height = /*...*/;
int depth = /*...*/;
int *matrix = new int[width * height * depth];

int &cell_xyz = matrix[x + y * width + z * width * height];

delete[] matrix;

[bigtrace]

Hi,

wut you said make sense to me, but I need to use the form like this : a[i][j][k] to access the data.

If I created a 1-d array, it would be difficult to overload three [][][] to achieve the same function?

If I use the pointer, then I can just overload the first [] and return a pointer that can access the data I want.

[helios]

I would suggest to not even bother with this and just use an at(size_t, size_t, size_t) member.

template <typename T, size_t N>
class ArrayAccessor{
    T *array;
    size_t *dimensions;
    size_t offset;
    ArrayAccessor<T, N - 1> next;
public:
    ArrayAccessor(T *array, size_t offset, size_t *dimensions):
            array(array),
            offset(offset),
            dimensions(dimensions){
        
    }
    ArrayAccessor<T, N - 1> &operator[](size_t offset){
        this->next = ArrayAccessor<T, N - 1>(
            this->array + this->offset * *this->dimensions,
            offset,
            this->dimensions + 1
        );
        return this->next;
    }
};

template <typename T>
class ArrayAccessor<T, 1>{
    T *array;
    size_t offset;
public:
    ArrayAccessor(T *array, size_t offset, size_t *dimensions):
        array(array),
        offset(offset)
        {}
    T &operator[](size_t offset){
        return this->array[this->offset * *this->dimensions];
    }
};

template <typename T>
class Matrix3{
    T *array;
    size_t width, height, depth;
    size_t dimensions[3];
public:
    Matrix3(size_t width, size_t height, size_t depth){
        //...
        this->dimensions[0] = 1;
        this->dimensions[1] = width;
        this->dimensions[2] = width * height;
        //...
    }
    ArrayAccessor<T, 3> operator[](size_t offset){
        return ArrayAccessor<T, 3>(this->array, offset, this->dimensions);
    }
};