[ITP - Lecture 13] Introduction to Pointers

An Introduction to Pointers Intro to Programming
MUHAMMAD HAMMAD WASEEM 1
An Introduction to Pointers
Which feature of C do beginners find most difficult to understand? The answer is easy: pointers.
The difficulty beginners have with pointers has much to do with C’s pointer terminology than the
actual concept. In our discussion of C pointers, therefore, we will try to avoid this difficulty by
explaining pointers in terms of programming concepts we already understand.
The first thing we want to do is explain the rationale of C’s pointer notation. Consider the
declaration, int i = 3 ;
This declaration tells the C compiler to:
a) Reserve space in memory to hold the integer value.
b) Associate the name i with this memory location.
c) Store the value 3 at this location.
We may represent i’s location in memory by the following memory map.
We see that the computer has selected memory location 65524 as the place to store the value 3.
The location number 65524 is not a number to be relied upon, because some other time the computer
may choose a different location for storing the value 3. The important point is, i’s address in memory is
a number.
We can print this address number through the following program:
main( )
{
int i = 3 ;
printf ( "nAddress of i = %u", &i ) ;
printf ( "nValue of i = %d", i ) ;
}
The output of the above program would be:
Address of i = 65524
Value of i = 3
Look at the first printf( ) statement carefully. ‘&’ used in this statement is C’s ‘address of’
operator. The expression &i returns the address of the variable i, which in this case happens to be
65524.
The other pointer operator available in C is ‘*’, called ‘value at address’ operator. It gives the value
stored at a particular address. The ‘value at address’ operator is also called ‘indirection’ operator.
Observe carefully the output of the following program:
main( )
{
int i = 3 ;

printf ( "nValue of i = %d", *( &i ) ) ;
}
Value of i = 3
Value of i = 3
Note that printing the value of *( &i ) is same as printing the value of i.
The expression &i gives the address of the variable i. This address can be collected in a variable, by
saying,
j = &i ;
But remember that j is not an ordinary variable like any other integer variable and compiler must
provide it space in the memory. The following memory map would illustrate the contents of i and j.
As you can see, i’s value is 3 and j’s value is i’s address. But, we can’t use j in a program without
declaring it. And since j is a variable that contains the address of i, it is declared as,
int *j ;
This declaration tells the compiler that j will be used to store the address of an integer value. In
other words j points to an integer.
Here is a program that demonstrates the relationships we have been discussing.
main( )
{
int i = 3 ;
int *j ;
j = &i ;
printf ( "nAddress of i = %u", j ) ;
printf ( "nAddress of j = %u", &j ) ;
printf ( "nValue of j = %u", j ) ;
printf ( "nValue of i = %d", *( &i ) ) ;
printf ( "nValue of i = %d", *j ) ;
}
Address of j = 65522
Value of j = 65524
Value of i = 3

Value of i = 3
Value of i = 3
Pointers to Other Data Types
Look at the following declarations,
int *alpha ;
char *ch ;
float *s ;
Here, alpha, ch and s are declared as pointer variables, i.e. variables capable of holding
addresses. Remember that, addresses (location nos.) are always going to be whole numbers, therefore
pointers always contain whole numbers.
The declaration float *s does not mean that s is going to contain a floating-point value. What it
means is, s is going to contain the address of a floating-point value. Similarly, char *ch means that
ch is going to contain the address of a char value. Or in other words, the value at address stored in ch
is going to be a char.
Pointer towards a Pointer
The concept of pointers can be further extended. Pointer variable itself might be another pointer.
Thus, we now have a pointer that contains another pointer’s address. The following example should
make this point clear.
main( )
{
int i = 3, *j, **k ;
j = &i ;
k = &j ;
printf ( "nAddress of i = %u", j ) ;
printf ( "nAddress of i = %u", *k ) ;
printf ( "nAddress of j = %u", &j ) ;
printf ( "nAddress of j = %u", k ) ;
printf ( "nAddress of k = %u", &k ) ;
printf ( "nValue of j = %u", j ) ;
printf ( "nValue of k = %u", k ) ;
printf ( "nValue of i = %d", * ( &i ) ) ;
printf ( "nValue of i = %d", *j ) ;
printf ( "nValue of i = %d", **k ) ;
}
Address of k = 65520

Value of j = 65524
Value of k = 65522
Value of i = 3
Value of i = 3
Value of i = 3
Value of i = 3
Remember that when you run this program the addresses that get printed might turn out to be
something different than the ones shown in the figure. However, with these addresses too the
relationship between i, j and k can be easily established.
Observe how the variables j and k have been declared,
int i, *j, **k ;
Here, i is an ordinary int, j is a pointer to an int (often called an integer pointer), whereas k is a
pointer to an integer pointer. We can extend the above program still further by creating a pointer to a
pointer to an integer pointer. In principle, you would agree that likewise there could exist a pointer to
a pointer to a pointer to a pointer to a pointer. There is no limit on how far can we go on extending this
definition.
Back to Function Calls
Having had the first tryst with pointers let us now get back to what we had originally set out to
learn—the two types of function calls—call by value and call by reference. Arguments can generally be
passed to functions in one of the two ways:
a) Sending the values of the arguments
b) Sending the addresses of the arguments
In the first method the ‘value’ of each of the actual arguments in the calling function is copied into
corresponding formal arguments of the called function. With this method the changes made to the
formal arguments in the called function have no effect on the values of actual arguments in the calling
function. The following program illustrates the ‘Call by Value’.
main( )
{
int a = 10, b = 20 ;
swapv ( a, b ) ;
printf ( "na = %d b = %d", a, b ) ;
}
swapv ( int x, int y )
{
int t ;
t = x ;
x = y ;

y = t ;
printf ( "nx = %d y = %d", x, y ) ;
}
x = 20 y = 10
a = 10 b = 20
Note that values of a and b remain unchanged even after exchanging the values of x and y.
In the second method (call by reference) the addresses of actual arguments in the calling function
are copied into formal arguments of the called function. This means that using these addresses we
would have an access to the actual arguments and hence we would be able to manipulate them. The
following program illustrates this fact.
main( )
{
int a = 10, b = 20 ;
swapr ( &a, &b ) ;
printf ( "na = %d b = %d", a, b ) ;
}
swapr( int *x, int *y )
{
int t ;
t = *x ;
*x = *y ;
*y = t ;
}
a = 20 b = 10
Note that this program manages to exchange the values of a and b using their addresses stored in x
and y.
Usually in C programming we make a call by value. This means that in general you cannot alter the
actual arguments. But if desired, it can always be achieved through a call by reference.
Using a call by reference intelligently we can make a function return more than one value at a time,
which is not possible ordinarily.
main( )
{
int radius ;
float area, perimeter ;
printf ( "nEnter radius of a circle " ) ;
scanf ( "%d", &radius ) ;
areaperi ( radius, &area, &perimeter ) ;
printf ( "Area = %f", area ) ;
printf ( "nPerimeter = %f", perimeter ) ;
}
areaperi ( int r, float *a, float *p )
{

*a = 3.14 * r * r ;
*p = 2 * 3.14 * r ;
}
And here is the output...
Enter radius of a circle 5
Area = 78.500000
Perimeter = 31.400000
Thus, we have been able to indirectly return two values from a called function, and hence, have
overcome the limitation of the return statement, which can return only one value from a function at a
time.
Conclusions
From the programs that we discussed here we can draw the following conclusions:
a) If we want that the value of an actual argument should not get changed in the function
being called, pass the actual argument by value.
b) If we want that the value of an actual argument should get changed in the function being
called, pass the actual argument by reference.
c) If a function is to be made to return more than one value at a time then return these values
indirectly by using a call by reference.

[ITP - Lecture 13] Introduction to Pointers

Recommended

More Related Content

What's hot (20)

Similar to [ITP - Lecture 13] Introduction to Pointers (20)

More from Muhammad Hammad Waseem (20)

Recently uploaded (20)

[ITP - Lecture 13] Introduction to Pointers