C Arrays and Pointers

• In Java, pointers are easy to deal with

– In fact, there is little that can go wrong in Java since pointer
access is done for you
• the only exception is in passing an object to a method without
knowing if the method will change the object or not (for instance,
Strings cannot be changed in a method like concat)
• In C, pointers are more challenging
– You will need to know
• when to use a pointer
• when to dereference the pointer
• when to pass an address of a variable rather than the variable itself
• when to use pointer arithmetic to change the pointer
• how to use pointers without making your programs unreadable
– Basically, you have to learn how to not “shoot yourself in
the foot” with pointers
 The Basics
• A pointer is merely an address of where a datum or structure is
stored
– all pointers are typed based on the type of entity that they point to
– to declare a pointer, use * preceding the variable name as in int *x;
• To set a pointer to a variable’s address use & before the variable
as in x = &y;
– & means “return the memory address of”
– in this example, x will now point to y, that is, x stores y’s address
• If you access x, you merely get the address
• To get the value that x points to, use * as in *x
– *x = *x + 1; will add 1 to y
• * is known as the indirection (or dereferencing) operator because
it requires a second access
– that is, this is a form of indirect addressing
 Example Code
int x = 1, y = 2, z[10];
int *ip; // ip is a pointer to an int, so it can point to x, y, or an element of z

ip = &x; // ip now points at the location where x is stored

y = *ip; // set y equal to the value pointed to by ip, or y = x
*ip = 0; // now change the value that ip points to to 0, so now x = 0
// but notice that y is unchanged
ip = &z[0]; // now ip points at the first location in the array z

*ip = *ip + 1; // the value that ip points to (z[0]) is incremented

int x, *y, z, *q;

x = 3;
y = &x; // y points to x
printf("%d\n", x); // outputs 3
printf("%d\n", y); // outputs x’s address, will seem like a random number to us
printf("%d\n", *y); // outputs what y points to, or x (3)
printf("%d\n", *y+1); // outputs 4 (print out what y points to + 1)
printf("%d\n", *(y+1)); // this outputs the item after x in memory – what is it?
z = *(&x); // z equals 3 (what &x points to, which is x)
q = &*y; // q points to 3 – note *& and &* cancel out
 Arrays and Pointers
• We declare an array using [ ] in our declaration following the variable name
– int x[5]; // unlike Java, we can’t do int[ ] x;
• You must include the size of the array in the [ ] when declaring unless you
are also initializing the array to its starting values as in:
– int x [ ] = {1, 2, 3, 4, 5};
– you can also include the size when initializing as long as the size is >= the
number of items being initialized (in which case the remaining array elements are
uninitialized)
• As in Java
– you access array elements just as in Java as in x[4]
– array indices start at 0
– arrays can be passed as parameters, the type being received would be denoted as
int x[ ]
• Arrays in C are interesting because they are pointed to
– the variable that you declare for the array is actually a pointer to the first array
element
• You can interact with the array elements either through pointers or by using [
]
• One of the intriguing features of pointers in C is the ability to manipulate the
pointers through pointer arithmetic – a pointer is an int value, so we can add
or subtract
– this will be used for stepping through arrays rather than using array indices
 Using Pointers with Arrays
• Recall in an earlier example, we did ip =
&z[0];
• Notice that ip=ip+1 (or ip++)
• This sets our pointer to point at the first moves the pointer 4 bytes instead
element of the array of 1 to point at the next array
– In fact, z is a pointer as well and we can location
access z[0] either using z[0], *ip, or *z – The amounted added to the pointer is
• What about accessing z[1]? based on the size of the array element
– We can do z[1] as usual, or we can add 1 • 8 for an array of doubles
to the location pointed to by ip or z, that • 1 for an array of chars (strings)
is *(ip+1) or *(z+1) • 4 for an array of ints
– While we can reset ip to be ip = ip+1, • We can declare our arrays using
we cannot reset z to be z = z+1
– adding 1 to ip will point to z[1], but if z
pointers instead of [ ]
= z + 1 were legal, we would lose access – notably, we might do this for our
to the first array location since z is our formal parameters as this better
array variable describes what we are dealing with)
– for instance, function1(int *array)
rather than function1(int[ ] array)
– We wouldn’t normally do this to
declare our arrays as the array’s
pointer exists but not the array itself
 Iterating Through the Array
• Here we see two ways to iterate through an array, the usual way,
but also a method using pointer arithmetic
int j; int *pj;
for(j = 0; j < n; j++) for(pj = a; pj < a + n; pj++)
a[j]++; (*pj)++;
• Let’s consider the code on the right:
– pj is a pointer to an int
– We start with pj pointing at a, that is, pj points to a[0]
– The loop iterates while pj < a + n
• pj is a pointer, so it is an address
• a is a pointer to the beginning of an array of n elements so a + n is the size of the array
• pj++ increments the pointer to point at the next element in the array
• The instruction (*pj)++ says “take what pj points to and increment it”
– NOTE: (*pj)++; increments what pj points to, *(pj++); increments the pointer to point at the next array
element
• what do each of these do? *pj++; ++*pj;
Array Example Using a Pointer
int x[4] = {12, 20, 39, 43}, *y;
y = &x[0]; // y points to the beginning of the array
printf("%d\n", x[0]); // outputs 12
printf("%d\n", *y); // also outputs 12
printf("%d\n", *y+1); // outputs 13 (12 + 1)
printf("%d\n", (*y)+1); // also outputs 13
printf("%d\n", *(y+1)); // outputs x[1] or 20
y+=2; // y now points to x[2]
printf("%d\n", *y); // prints out 39
*y = 38; // changes x[2] to 38
printf("%d\n", *y-1); // prints out x[2] - 1 or 37
*y++; // sets y to point at the next array element
printf("%d\n", *y); // outputs x[3] (43)
(*y)++; // sets what y points to to be 1 greater
printf("%d\n", *y); // outputs the new value of x[3] (44)
 Strings
• There is no string type, we implement strings as arrays of chars
– char str[10]; // str is an array of 10 chars or a string
– char *str; // str points to the beginning of a string of
unspecified length
• There is a string.h library with numerous string functions
– they all operate on arrays of chars and include:
• strcpy(s1, s2) – copies s2 into s1 (including ‘\0’ as last char)
• strncpy(s1, s2, n) – same but only copies up to n chars of s2
• strcmp(s1, s2) – returns a negative int if s1 < s2, 0 if s1 = = s2 and a positive
int if s1 > s2
• strncmp(s1, s2, n) – same but only compares up to n chars
• strcat(s1, s2) – concatenates s2 onto s1 (this changes s1, but not s2)
• strncat(s1, s2, n) – same but only concatenates up to n chars
• strlen(s1) – returns the integer length of s1
• strchr(s1, ch) – return a pointer to the first occurrence of ch in s1 (or NULL if
ch is not present)
• strrchr(s1, ch) – same but the pointer points to the last occurrence of ch
• strpbrk(s1, s2) – return a pointer to the first occurrence of any character in s1
that matches a character in s2 (or NULL if none are present)
• strstr(s1, s2) – substring, return a pointer to the char in s1 that starts a substring
that matches s2, or NULL if the substring is not present
 Implementing Some of These
void strcpy(char *s, char *t)
int strcmp(char *s, char *t)
int strlen(char *s) {
{
{ int i = 0;
int i;
int n; while((s[i] = t[i]) != ‘\0’)
for(i=0;s[i] = = t[i];i++)
for(n = 0; *s != ‘\0’; s++) i++;
if(s[i] = = ‘\0’)
n++; }
return 0;
return n;
return s[i] – t[i];
}
} void strcpy(char *s, char *t)
{
int strcmp(char *s, char *t) while((*s = *t) != ‘\0’)
{ {
for( ; *s = = *t; s++, t++) s++; t++;
Notice in the second if(*s = = ‘\0’) return 0; }
strcmp and second return *s - *t; }
and third strcpy the }
use of pointers to iterate
through the strings void strcpy(char *s, char *t)
{
The conciseness of the last strcmp and strcpy make them while((*s++ = *t++) != ‘\0’);
hard to understand }
 More On Pointer Arithmetic
• We can also perform subtraction on pointers

int a[10] = {…};

int *ip;
for(ip = &a[9]; ip >= a; ip--)
• Here, we pass… to a function the address
of the third
element of an array (&a[2]) and use pointer subtraction to
get to a[0] and a[1])
int addem(int *ip)
{
int a[3] = {…}; int temp;
printf(“%d”, addem(&a[2])); temp = *ip + *(ip – 1) + *(ip – 2);
return temp;
}
Recall:
If a is an array, and p = &a[0] then we can reference array
a[0] = *a and elements as a[i], *(p+i), but we can also reference them as
a[i] = *(a + i) p[i] and *(a+i) – that is, a and p are both pointers to the array
And can be dereferenced by * or by [ ]
 Multidimensional Arrays
• As in Java, C allows multidimensional arrays by using more [ ]
– Example: int matrix[5][10 ];
• Some differences:
– Because functions can be compiled separately, we must denote all but one
dimension of a multiple dimensional array in a function’s parameter list
• void afunction(int amatrix[ ][10]);
– Because arrays are referenced through pointers, there are multiple ways to
declare and access 2+ dimensional arrays
• This will be more relevant when dealing with an array of strings (which is a 2-D array)

int a[10][20]; int *a[3]; // array of 3 pointers

int *a[10]; int x[2] = {1, 2};
int **a; int y[3] = {3, 4, 5};
int z[4] = {6, 7, 8, 9};
*a[4] –first element of 5th array element *a = &x[0]; // a[0] points to x[0]
*a[9] –first element of 10th array element *(a+1) = &y[0]; // a[1] points to y[0]
**a –first element of a[0] *(a+2) = &z[0]; // a[2] points to z[0]
// array a is a jagged array, it is not
// rectangular, or of equal dimensions
 Pointers to Pointers
• As indicated in the last slide, we can have an array
of arrays which is really an array of pointers or
pointers to pointers
– We may wish to use pointers to pointers outside of
arrays as well, although it is more common that
pointers to pointers represent array of pointers
– Consider the following:

int a; We dereference our pointer p with *p but we dereference

int *p; our pointer to a pointer q with **q
int **q;
a = 10; *q is actually p, so **q is a
p = &a;
q = &p;
printf(“%d”, **q); // outputs 10
 Arrays of Strings Implementation
• We could implement an array of strings as a 2-D array of chars
– char array[10][10];
• This has two disadvantages
– All strings will be 10 chars long
– Requires 2 nested for-loops for most operations such as string comparison
or string copying, which can become complicated
• Instead, we will implement our array of strings as an array of
pointers
– char *array[10];
• Each pointer points to one string
– Follow the string through the pointer
– Go to the next string using a for-loop
– Because strcpy, strcmp, strlen all expect pointers, we can use these by
passing an array element (since each array element is a pointer to a string)
 Example
char *x[ ] = {"hello", "goodbye", "so long", "thanks for all the fish"};
// our array of strings x is a set of 4 pointers
char *y; // let y be a pointer to a char so it can be used to move through a single string
int i;
for(i=0;i<4;i++) // iterate for each string in x
{
y = x[i]; // x[i] is an array, x is really a pointer, so this sets y to x’s starting addr.
while(*y!='\0') // while the thing y points to is not the end of a string
{
printf("%c", *y); // print what y points to
y++; // and go on to the next char in x
}
printf("\n"); // separate strings in output with \n
}

• Notice that if we had used char x[ ][ ] = {…}; then the storage

space would have been 4 strings of length 23 (the length of the
longest string) or 92 bytes instead of 42 bytes as it is above
 Passing Arrays
• When an array is passed to • Because you can compile
a function, what is being functions separately, the
passed is a pointer to the compiler must be able to
array “know” about an array being
– In the formal parameter list, passed in to a function, so you
you can either specify the must specify all (or most) of
parameter as an array or a the definition:
pointer – The type and all dimensions
except for the first
int array[100];
… int array[5][10][15];
afunction(array); …
… afunction(array);
…
void afunction(int *a) {…} void afunction(int a[ ][10][15]) {…} or
or void afunction(int *a[10][15]) {…} or
void afunction(int a[ ]) {…} void afunction(int a[5][10][15]) {…} or
void afunction(int **a[15]) {…} etc
 Some Additional Comments
• In functions, do not do return p; where p is a pointer
– Recall local variables are deallocated when the function ends
• so whatever p is pointing to will no longer be available
• but if you return the pointer, then you still are pointing at that memory
location even though you no longer know what is there
• We can declare a pointer to point to a void type, which
means that the pointer can point to any type
– However, this does require a cast before the pointer can be
assigned
• int x; float y; void *p; // p can point to either x or y
• p = (int *) &x; // p can point to int x once the address is cast
• p = (float *) &y; // or p can point to float y
• Pointers that don’t currently point to anything have the
special value NULL and can be tested as (p = = NULL)
or (!p), and (p != NULL) or (p)
Pointer to pointer
 Syntax
How to declare a pointer to pointer in C?
Declaring Pointer to Pointer is similar to declaring pointer in C. The
difference is we have to place an additional ‘*’ before the name of
pointer.
Syntax:
int **ptr; // declaring double pointers
#include <stdio.h>
// C program to demonstrate pointer to pointer
int main()
{
int var = 789;
// pointer for var
int *ptr2;
// double pointer for ptr2
int **ptr1;
// storing address of var in ptr2
ptr2 = &var;
// Storing address of ptr2 in ptr1
ptr1 = &ptr2;
// Displaying value of var using
// both single and double pointers
printf("Value of var = %d\n", var );
printf("Value of var using single pointer = %d\n",
*ptr2 );
printf("Value of var using double pointer = %d\n",
**ptr1);

return 0;
}
 C
Passing arrays to a Function
Pointers with arrays
Pointers with functions
 Pass arrays to a function
• Single element of an array can be passed in similar manner as passing
variable to a function.
Passing an entire one-dimensional array to a function
While passing arrays as arguments to the function, only the name of the array is
passed (i.e., starting address of memory area is passed as argument).
Passing Multi-dimensional Arrays
To pass two-dimensionalto Function
array to a function as an argument, starting address of
memory area reserved is passed as in one dimensional array
 Pointer to an Array
Declaration of array
int arr[5] = { 1, 2, 3, 4, 5 };

Compiler allocates sufficient amount of memory to contain all the elements

of the array.
Base address: Base address i.e. address of the first element of the array
(also allocated by the compiler).
From the above example
Base address is 1000 i.e., arr[0]
 Pointer to an Array
Declaration of array
int arr[5] = { 1, 2, 3, 4, 5 };

arr will give the base address, which is a constant pointer pointing to the
first element of the array, arr[0].
Hence arr contains the address of arr[0] i.e 1000
Printf(“address of array is =%u \n”,arr);
Printf(“address of array is =%u \n”,&arr[0]);
Pointer to an Array (Examples)
Pointer to an Array (Examples)
Pointer to Multidimensional Array
Pointer to Multidimensional Array
A multidimensional array is of form, a[i][j]
In a[i][j], a will give the base address of this array, even a + 0 + 0 will also
give the base address, that is the address of a[0][0] element.
Pointer to Multidimensional Array
 Passing Pointer to a function
Just like any other argument, pointers can also be passed to a function
as an argument. 
 
There are two ways to pass arguments/parameters to function calls – 
call by value  
call by reference.
 Call by values
In call by value, If you change the value of function parameter, it is
changed for the current function only.

It will not change the value of variable inside the caller method such as
main()
Call by value (Example)
 call by reference

 When we pass a pointer as an argument instead of a variable then

the address of the variable is passed instead of the value. 

 So actual and formal arguments shares the same address space.

Hence, value changed inside the function, is reflected inside as well
as outside the function.

 This technique is known as call by reference in C.

call by reference (Example)
Difference between call by reference
and call by reference (Example)
Difference between call by reference
and call by reference (Example)
Call by value Call by reference
1 A copy of value is passed to An address of value is
the function passed to the function
2 Changes made inside the Changes made inside the
function is not reflected on function is reflected outside
other functions the function also
3 Actual and formal arguments Actual and formal arguments
will be created in different will be created in same
memory location memory location
 Assignments
1. Write a c program for Student using functions concept with following
parameter
a) Take Name and marks as arrays
b) Create a function AvgM to calculate the average of 5 marks where were
given in array
c) Create a function displayS to display student name and average marks and
their grade
2. Write a c program for finding multiplication of two matrix using functions
3. Write a c program for sum of array elements using pointer to array concepts
4. Write a c program for sum two matrices using pointer to array concepts
5.  Write a C program for swapping of two number using call by value and call
by reference.