Dynamically Allocating 2-D Arrays

Spring Semester 2011 Programming and Data Structure 1

 You may recall ….

• We have discussed earlier the issue of dynamically

allocating space for 1-D arrays.
– Using malloc() library function.

• Pros and cons of this approach:

– The space gets allocated in global data area
called heap (not on the stack), and hence does
not evaporate at the end of function call.
– The conventional method allocates space in the
stack as part of the activation record, and so is
not available across function calls.

Spring Semester 2011 Programming and Data Structure 2

 Looking back at pointer arithmetic

int *p, (*q)[5], *r[3], **s;

• The variable ‘p’ points to an integer. Thus, p+i means:
p + i * sizeof(int)
• The variable ‘q’ points to an integer array of size 5.
Hence, q+i will mean: q + i * 5 * sizeof(int)
• ‘r’ is not a variable but a constant pointer. And so, r+i
will mean: r + i * sizeof(int *)
• Finally, the variable ‘s’ points to a location of type
int * . Thus, s+i will mean:
s + i * sizeof (int *)

Spring Semester 2011 Programming and Data Structure 3

 Some typical values ….

sizeof(int): 4
sizeof(int *): 4
sizeof(int [5]): 20
sizeof(int (*)[5]): 4
sizeof(int **): 4

Spring Semester 2011 Programming and Data Structure 4

How was 1-D array dynamically allocated?

• Sample code segment:

int *p, n, i;
scanf (”%d”, &n);
p = (int *) malloc (n * sizeof(int));

• Array elements can be accessed equivalently

as:
p[i] = 20;
*(p+i) = 20;

Spring Semester 2011 Programming and Data Structure 5

Methods to allocate space for 2-D array

1. Variable number of rows, fixed number of

columns
2. Variable number of columns, but fixed
number of rows
3. Both number of rows and columns
variable

Spring Semester 2011 Programming and Data Structure 6

 1:: Allocating space for 2-D array n×5

• We can use a pointer of type (*q)[5] to

allocate space for the array of n rows and 5
columns.

int (*q)[5];

q = (int (*)[5]) malloc

(n*5*sizeof(int));

Spring Semester 2011 Programming and Data Structure 7

 q[0][0] q[1][0] q[2][0]

q
Dynamically allocated memory

Spring Semester 2011 Programming and Data Structure 8

#include <stdio.h>
#include <stdlib.h>
int main()
{
int (*q)[5],rows,i,j;
printf("Enter the number of Rows: ") ;
scanf("%d", &rows);

q = (int (*)[5]) malloc (rows*5*sizeof(int));

for(i=0; i<rows; ++i)

for(j=0; j<5; ++j)
q[i][j]=2*i+3*j ;

Spring Semester 2011 Programming and Data Structure 9

 for(i=0; i<rows; ++i) {
for(j=0; j<5; ++j)
printf("%d ", q[i][j]); printf("\n");
}

return 0;
}

Enter the number of Rows: 3

0 3 6 9 12
2 5 8 11 14
4 7 10 13 16

Spring Semester 2011 Programming and Data Structure 10

• Some observations:
– ‘q’ points to the 0th row of a 5-element array.
– ‘q+i’ points to the ith row of a 5-element array.
– *q is the address of q[0][0], that is, &q[0][0].
– *q+j is the address of q[0][j], that is, &q[0][j].
– *(q+i)+j is address of q[i][j], that is, &q[i][j].
– **q is q[0][0].
– *(*q+j) is q[0][j].
– *(*(q+i)+j) is q[i][j].

Spring Semester 2011 Programming and Data Structure 11

2:: Allocating space for 2-D array 3×m

• We can use a pointer array of size 3, where

the ith element of the array will point to the
ith column of length m.
– Possible to have different number of elements in
different rows.

int *r[3], i;
for (i=0;i<3;i++)
r[i] = (int *) malloc (m*sizeof(int));

Spring Semester 2011 Programming and Data Structure 12

 r[0]

r[1]
r[2]

Statically allocated Dynamically allocated

pointer array memory

Spring Semester 2011 Programming and Data Structure 13

#include <stdio.h>
#include <stdlib.h>
int main()
{
int *r[3], i, j, col;
for(i=0; i<3; ++i) {
col = 2 * (i+1);
r[i] = (int *) malloc (col*sizeof(int));
for(j=0; j<col; ++j)
r[i][j] = i + j;
}
Spring Semester 2011 Programming and Data Structure 14
 for(i=0; i<3; ++i) {
col = 2 * (i+1);
for(j=0; j<col; ++j)
printf("%d ", r[i][j]);
printf("\n");
}
return 0; 0 1
} 1 2 3 4
2 3 4 5 6 7

Spring Semester 2011 Programming and Data Structure 15

• Some observations:
– r[i] is the ith pointer, which stores the
address of the 0th element of the ith row.
– So, r[i]+j is the address of the jth element
of the ith row.
– *(r[i]+j), same as r[i][j], is the jth
element of the ith row.

Spring Semester 2011 Programming and Data Structure 16

 3: Dynamic allocation of r×c array

• We can allocate a 2-D array of variable

number of rows and columns, where both
the number of rows and the number of
columns as inputs.

int **s;
s = (int **) malloc (r*sizeof(int *));
for (i=0;i<r;i++)
s[i] = (int *) malloc (c*sizeof(int));

Spring Semester 2011 Programming and Data Structure 17

 s Static allocation

s[0]

s[1]

s[2]
:
Dynamically allocated memory

Spring Semester 2011 Programming and Data Structure 18

#include <stdio.h>
#include <stdlib.h>
int main()
{
int **s, row, column, i, j;
printf("Enter Row & Column:\n") ;
scanf("%d%d", &row, &column) ;
s = (int **) malloc(row*sizeof(int *)) ;
for(i=0; i<row; ++i) {
s[i] = (int *) malloc(column*sizeof(int)) ;
for(j=0; j<column; ++j)
s[i][j] = i+j ;
}
Spring Semester 2011 Programming and Data Structure 19
 for(i=0; i<row; ++i) {
for(j=0; j<column; ++j)
printf("%d ", s[i][j]);
printf("\n") ;
}
return 0;
} Enter Row and Column:
3 5
0 1 2 3 4
1 2 3 4 5
2 3 4 5 6

Spring Semester 2011 Programming and Data Structure 20

• Some observations:
– s+i is the address of the ith element of the
pointer array.
– *(s+i), which is the same as s[i], is the ith
element of the pointer array that stores the
address of the 0th element of the ith row.
– s[i]+j is the address of the jth element of
the ith row.
– *(s[i]+j), which is the same as s[i][j],
is the jth element of the ith row.

Spring Semester 2011 Programming and Data Structure 21

 Example with 2-D Array
#include <stdio.h>
#include <stdlib.h>

int **allocate (int h, int w)

{
int **p; Allocate array
int i, j; of pointers

p = (int **) calloc (h, sizeof(int *) );

for (i=0;i<h;i++)
p[i] = (int *) calloc (w,sizeof(int));
return(p);
} Allocate array of
integers for each row
Spring Semester 2011 Programming and Data Structure 22
void read_data (int **p, int h, int w)
{
int i, j;
for (i=0;i<h;i++)
for (j=0;j<w;j++)
scanf ("%d", &p[i][j]);
}

Elements accessed
like 2-D array elements.

Spring Semester 2011 Programming and Data Structure 23

void print_data (int **p, int h, int w)
{
int i, j;
for (i=0;i<h;i++)
{
for (j=0;j<w;j++)
printf ("%5d ", p[i][j]);
printf ("\n");
}
}

Spring Semester 2011 Programming and Data Structure 24

main()
{
int **p;
int M, N;

printf ("Give M and N \n");

scanf ("%d%d", &M, &N);
p = allocate (M, N);
read_data (p, M, N);
printf ("\nThe array read as \n");
print_data (p, M, N);
}

Spring Semester 2011 Programming and Data Structure 25

 Give M and N
3 3
1 2 3
4 5 6
7 8 9
The array read as
1 2 3
4 5 6
7 8 9

Spring Semester 2011 Programming and Data Structure 26