Lecture 03
Arrays & pointers
In this lecture
• Declaring arrays
o 1D and 2D arrays
o Arrays as pointers
• Pointers and Arrays
• Exercises
An array is a contiguous block of memory allocated in the run time stack.
For example an array declared as
int A[10];
allocates 10*sizeof(int) bytes. Note that the sizeof operator provides the number of
bytes allocated for any data type.
A can also be accessed using its pointer representation. The name of the array A is a
constant pointer to the first element of the array. So A can be considered a const
int*. Since A is a constant pointer, A = NULL would be an illegal statement.
Other elements in the array can be accessed using their pointer representation as
follows.
&A[0] = A
&A[1] = A + 1
&A[2] = A + 2
…..
&A[n-1] = A + n-1
If the address of the first element in the array of A (or &A[0]) is FFBBAA0B then the
address of the next element A[1] is given by adding 4 bytes to A.
That is &A[1] = A + 1 = FFBBAA0B + 4 = FFBBAA0F
And &A[2] = A + 2 = FFBBAA0B + 8 = FFBBAA13
Note that the when doing address arithmetic, the number of bytes added depends
on the type of the pointer. That is int* adds 4 bytes, char* adds 1 byte etc. You can
type in this simple program to understand how a 1-D array is stored.
Program_3_1:
#include <stdio.h>
#define n 5
Copyright @ 2008 Ananda Gunawardena
int main(int argc, char* argv[]){
int A[n],i=0;
for (i=0;i<n;i++)
printf(“%x “,A+i);
printf(“\n”);
}
bf802330 bf802334 bf802338 bf80233c bf802340
Two Dimensional Arrays
Static 2-D arrays in C can be defined as
#define n 2
#define m 3
int A[n][m];
OR can be defined and initialized as
int A[2][3]={{1,2,3},{4,5,6}};
Here n represent the number of rows and m represents the number of columns. 2-D
arrays are represented as a contiguous block of n blocks each with size m (i.e. can
hold m integers(or any data type) in each block). The entries are stored in the
memory as shown above. Type in the following program to see where the elements
are stored.
Program_3_2:
#include <stdio.h>
#define n 2
#define m 3
int main(int argc, char* argv[]){
int A[n][m]={{3,2,4},{7,1,9}},i=0,j=0;
for (i=0;i<n;i++)
for (j=0;j<m;j++)
printf(“%x “,A[i]+j);
printf(“\n”);
for (i=0;i<n;i++)
for (j=0;j<m;j++)
printf("%d ",*(A[i]+j));
Copyright @ 2008 Ananda Gunawardena
printf("\n");
bfe3a1e0 bfe3a1e4 bfe3a1e8 bfe3a1ec bfe3a1f0 bfe3a1f4
3 2 4 7 1 9
Another way to think of a 2D array is as follows. Suppose we define 2D array as
int A[][3] = {{1,2,3},{4,5,6}};
here we did not specify the number of rows, but by virtue of initialization on the
right, A is assigned a block of 6 integers and the number of rows set to 2.
Here A of type int** refers to address of the first element in the array. Hence **A
refers to A[0][0]
Actually there are three ways to write A[0][0]
A[0][0] == **A == *A[0]
The address A+1 refers to the first element in the second row. So
A[1][0] == *(A+1) == *(A[0]+3)
Array of Pointers
An array of int* pointers is defined as
int* A[] or int** A;
Each element in the array A[i] is an address of an integer or int*. A 2-D array (or
matrix) of ints can be viewed as an array of int* where starting address of row 0 of
the matrix is equivalent to A[0], starting address of row 1 of the matrix is equivalent
to A[1] etc.
A[0][0] = *A[0]
A[0][1] = *(A[0]+1)
A[0][2] = *(A[0]+2) etc
A[1][0] = *A[1]
A[1][1] = *(A[1]+1) etc..
In general A[i][j] is equal to *(A[i]+j) or *(*(A+i)+j)
Copyright @ 2008 Ananda Gunawardena
Passing an Array of Pointers into a function
An array of pointers can be considered a type** variable.
We can pass a reference to this array to a function using its address. For example if
int** A;
Then we can write a foo function that takes the address of this array and do
something with it. A prototype of such a function would look like
void foo(int*** ptr);
A call to this function from the main program would look like
foo(&A);
Let us take a look at an example. Suppose we write a function that takes the address
of an array of int* (or the address of an int**) and build an array and also keep track
of the number of elements in the array and return that to main program. Assume
that the input comes from a file of integers where each line contains one integer.
Taking an input file such as
10
35
89
foo Will create a list that looks like
10
35
89
The memory for the array of int* and memory for each integer must be allocated
dynamically.
Program_3:
Copyright @ 2008 Ananda Gunawardena
int foo(int*** A){
FILE* fp=fopen(“foo.txt”,”r”);
int num=0,i=0;
*A = malloc(50*sizeof(int*)); // assume 50 initial blocks
while (fscanf(fp,”%d”,&num)!=EOF){
*(*A+i) = malloc(sizeof(int));
**(*A+i) = num;
}
return i;
}
Making Sense of Pointers
Pointers are memory addresses. The simplest kind of pointer (or 1-star) is an
address of a single memory location.
int* x;
we can allocate memory for this using
x = (int*)malloc(size);
and assign a value to it using
*x = some_integer;
Or pass it’s address &x to a function using foo(&x);
void foo(int** y){ **y = 10;} // changes *x to 10
In the above case function will manipulate the content at that address directly.
Pointer to a Pointer (or address of an address)
An array of pointers can be considered a pointer to a pointer. For example if we
define
int* A[n]; or int** A;
The former defines an array of n int*’s (no malloc necessary) and the latter defines
just a pointer to an array of pointers where malloc is necessary.
int** A;
A = (int**)malloc(n*sizeof(int*));
Copyright @ 2008 Ananda Gunawardena
A is the name of the array of pointers or the address of the first element.
A = &A[0]
A+1 = &A[1]
A+2 = &A[2] and so on.
We note A[i] is a int* and so we can allocate memory for that using,
A[i] = (int*)malloc(sizeof(int));
Now to assign a value to that memory, we can write
*A[i] = some_integer;
Passing the address of A to a function is tricky. Since A is an int**, the address of A or
&A is int*** (or a pointer to a int**). Consider the foo function below. We will call the
foo function by writing foo(&A);
void foo(int*** B){
// allocate memory for an array of n int*’s
*B = (int**)malloc(n*sizeof(int*));
// Allocate memory for i-th int* in the array
*(*B+i) = (int*)malloc(sizeof(int));
// allocate a value for that memory block
**(*B+i) = some_integer;
}
Note that the unary * operator is right associative.
Copyright @ 2008 Ananda Gunawardena
Exercises
1. Rewrite the program 7.3 so that foo takes an address of an array of int* and the
address of a count and write their values directly. The prototype would look like
void foo(int*** A, int* count);
A call from the main program would look like
int** A=NULL;
int count;
foo(&A, &count);
2. Write a function foo that takes the address of an array of char*’s and read a file of
strings (one per line) and assign each string to the next array location. The
prototype of the function can be:
void foo(char*** A, char* infile){
// size of the file is unknown. So we need to start with
// a fixed size (say n=10) and double the size as we
// need more.
3. Write a function that takes the address of a string and allocate memory to double
the size to hold the string. Need to copy the content of the original string to new one.
4. Given a 1D array of integers
int A[] = {1,2,3};
Find value and/or describe what they mean in each of the following.
a. A
b. A+1
c. *A+1
d. *(A+1)
e. *A[1]
5. Given a 2D array of integers
int A[][3] = {{1,2,3},{4,5,6}};
Find value and/or describe what they mean in each of the following.
a. A
b. A+1
c. *A+1
d. **A
Copyright @ 2008 Ananda Gunawardena
e. *A[1]
f. *(A[0]+2)
g. **(A+1)
h. A[1]+1
i. **A++;
Copyright @ 2008 Ananda Gunawardena
