Using pointers for double dimension memory allocation OR Dynamic Memory allocation for Multidimension Array

Many times you need to allocate dynamic memory for a multidimensional array in C language. This article deals with using pointers for dynamic memory allocation for two dimensional array , which can further be extended for higher dimensions.

Example of situation when u require 2-D dynamic allocation :

1. Take the input dimension of an matrix form the user and then get input values and print them.

2. Print a magic square after taking dimensions form user.

3. Implementing Hash Table after taking hash value form user.

I will try to explain the concept by solving the first problem (simply coz its the easy to solve :) and also for others to understand )

Problem Statement : Take the input dimension of an matrix form the user and then get input values and print them.

Solution :

first i will paste a working solution and the explain it :

i tried to copy paste the code but it gave some html error ... so im pasting the image ..... will soon find some way to post the code :)

please right click and open the image in a tab to see the code

Explanation :

Problem is we need to take input from the user at run time , so we cannot declare a 2-D array of fixed dimensions before hand , we need to do it at runtime , using dynamic memory allocation.

For this we use the concept of pointer to a pointer or Double pointer.

Now to revise the basics we can use a normal pointer to allocate memory for an array , i.e. a single dimension array. It can be done in following manner.

int *array;
int arraysize;
printf("enter the size of array");
scanf("%d ",&arraysize);

array=(int *)(malloc(sizeof(int)*arraysize));

what happened above is when i said int *array a pointer named array was assigned to point to a location where some int is supposed to reside. But by writing

array=(int *)(malloc(sizeof(int)*arraysize)) i have allocated memory dynamically equal to the arraysize given by the user, where each element is integer type.

if we analyze the right hand side of the statement:

array=(int *)(malloc(sizeof(int)*arraysize));

(int*) typecast the memory allocated to be a pointer to a integer, since array is of that type .

malloc(sizeof(int)*arraysize) dynamically allocates a memory of elements equal to arraysize and each element of size int , since sizeof(int) is used.

so in the end what we have is a single dimension array, whose base address is pointed by pointer array.

Now coming to the code that i have posted above for 2-D array :

the part of the code that deals with the 2-D dynamic allocation is :

these three lines are the only lines which u need to understand to get the concept :

Line 1: matrix=(int**)(malloc(sizeof(int*)*no_of_rows));

The variable matrix which is a integer pointer to a pointer is allocated memory allocated equal to no_of_rows and each of type pointer to an integer. So what we have now is an Array of integer Pointers of size equal to no_of_rows .

since matrix is a double pointer so we need to typecast the memory allocated to its type by (int**) and since we are allocating memory for array of pointers so we use sizeof(int*) .

Line 2 :

this is a simple for loop which is responsible to run the line below it no_of_rows time, so that each integer pointer from Array of Pointer can point to integer array itself .

Line 3 : *(matrix+i)=(int*)(malloc(sizeof(int)*no_of_column));

By *(matrix+i) we go to each integer pointer in the array of pointers for which we allocated memory in the Line: 1.

By (int*)(malloc(sizeof(int)*no_of_column)) we first typecast the allocated memory since *(matrix+i) is of type integer pointer we use (int*) and now we want to store integers in the allocated space to we use sizeof(int) .

That all the memory is allocated, rest of program is simple input and display.

For any more clarification feel free to comment.