In this article we will see how to allocate and deallocate 2D arrays dynamically using new / delete and malloc / free combinations.

Suppose we want to create a 2D array using pointers on heap either using new or malloc. It should function like this,

Now we should be able to access 2D array through ptr i.e.

Then we can deallocate the allocated 2D array using following function,

Now Let’s explore the solution,

To Store a 2D array we need a pointer to pointer i.e.

Algo to allocate 2D array dynamically on heap is as follows,

1.) 2D array should be of size [row][col].
2.) Allocate an array of int pointers i.e. (int *) of size row and assign it to int ** ptr.
3.) Traverse this int * array and for each entry allocate a int array on heap of size col.

Code to allocate 2D array dynamically on heap using new operator is as follows,

Code to allocate 2D array dynamically on heap using malloc function is as follows,

Algo to deallocate 2D array from heap is as follows,

1.) Traverse the array in int ** ptr and for each entry deallocate the int array stored in each int * .
2.) Deallocate the array int ** .

Code to deallocate the dynamically allocated 2D array using delete operator is as follows,

Code to deallocate the dynamically allocated 2D array using free function is as follows,

Complete executable code is as follows,

```
#include <iostream>
#include <stdlib.h>

int ** allocateTwoDimenArrayOnHeapUsingNew(int row, int col)
{
int ** ptr = new int*[row];
for(int i = 0; i < row; i++)
{
ptr[i] = new int[col];
}
return ptr;
}

int ** allocateTwoDimenArrayOnHeapUsingMalloc(int row, int col)
{
int ** ptr = (int **) malloc(sizeof(int *)*row);
for(int i = 0; i < row; i++)
{
ptr[i] = (int *) malloc(sizeof(int)*col);

}
return ptr;
}
void destroyTwoDimenArrayOnHeapUsingFree(int ** ptr, int row, int col)
{
for(int i = 0; i < row; i++)
{
free(ptr[i]);
}
free(ptr);
}

void destroyTwoDimenArrayOnHeapUsingDelete(int ** ptr, int row, int col)
{
for(int i = 0; i < row; i++)
{
delete [] ptr[i];
}
delete [] ptr;
}

void testbyHeap()
{

int row = 2;
int col = 3;

int ** ptr = allocateTwoDimenArrayOnHeapUsingNew(row, col);

ptr[0][0] = 1;
ptr[0][1] = 2;
ptr[0][2] = 3;

ptr[1][0] = 4;
ptr[1][1] = 5;
ptr[1][2] = 6;

for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
std::cout<<ptr[i][j]<<" , ";
}
std::cout<<std::endl;
}

destroyTwoDimenArrayOnHeapUsingDelete(ptr, row, col);
}

void testbyMalloc()
{

int row = 2;
int col = 3;

int ** ptr = allocateTwoDimenArrayOnHeapUsingMalloc(row, col);

ptr[0][0] = 1;
ptr[0][1] = 2;
ptr[0][2] = 3;

ptr[1][0] = 4;
ptr[1][1] = 5;
ptr[1][2] = 6;

for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
std::cout<<ptr[i][j]<<" , ";
}
std::cout<<std::endl;
}

destroyTwoDimenArrayOnHeapUsingFree(ptr, row, col);
}

int *** allocateThreeDimenArrayOnHeapUsingNew(int row, int col, int z)
{
int *** ptr = new int**[row];

for(int i = 0; i < row; i++)
{
ptr[i] = new int*[col];
for(int j = 0; j < col; j++)
{
ptr[i][j] = new int[z];
}

}

ptr[0][0][0] = 1;
ptr[0][0][1] = 2;
ptr[0][1][0] = 3;
ptr[0][1][1] = 4;
ptr[0][2][0] = 5;
ptr[0][2][1] = 6;

ptr[1][0][0] = 11;
ptr[1][0][1] = 12;
ptr[1][1][0] = 13;
ptr[1][1][1] = 14;
ptr[1][2][0] = 15;
ptr[1][2][1] = 16;

return ptr;
}

int main()
{
testbyHeap();
testbyMalloc();

int *** ptr = allocateThreeDimenArrayOnHeapUsingNew(2,3,2);

for(int i = 0; i < 2; i++)
{
for(int j = 0; j < 3; j++)
{
std::cout<<"(";
for(int k = 0; k < 2; k++)
{
std::cout<<ptr[i][j][k]<<",";
}
std::cout<<"),";
}
std::cout<<std::endl;
}
return 0;
}

```