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,
int row = 2; int col = 3; int ** ptr = allocateTwoDimenArrayOnHeapUsingNew(row, col);
Now we should be able to access 2D array through ptr i.e.
ptr[i][j] = 1;
Then we can deallocate the allocated 2D array using following function,
void destroyTwoDimenArrayOnHeapUsingDelete(int ** ptr, int row, int col)
Now Let’s explore the solution,
To Store a 2D array we need a pointer to pointer i.e.
int** ptr;
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.
[showads ad=inside_post]
Code to allocate 2D array dynamically on heap using new operator is as follows,
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; }
Code to allocate 2D array dynamically on heap using malloc function is as follows,
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; }
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,
void destroyTwoDimenArrayOnHeapUsingDelete(int ** ptr, int row, int col) { for(int i = 0; i < row; i++) { delete [] ptr[i]; } delete [] ptr; }
Code to deallocate the dynamically allocated 2D array using free function is as follows,
void destroyTwoDimenArrayOnHeapUsingFree(int ** ptr, int row, int col) { for(int i = 0; i < row; i++) { free(ptr[i]); } free(ptr); }
Complete executable code is as follows,
[code language=”cpp” collapse=”true”]
#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;
}
[/code]
Hi,
very informative and useful sharing.