CHAPTER 14

POINTERS

© Oxford University Press 2016. All rights reserved.

 UNDERSTANDING THE COMPUTER’S MEMORY
• Every computer has a primary memory. All our data and
programs need to be placed in the primary memory for
execution.
• The primary memory or RAM (Random Access Memory
which is a part of the primary memory) is a collection of
memory locations (often known as cells) and each location
has a specific address. Each memory location is capable of
storing 1 byte of data

© Oxford University Press 2016. All rights reserved.

• Generally, the computer has three areas of memory each of which is used for a
specific task. These areas of memory include- stack, heap and global memory.
• Stack- A fixed size of stack is allocated by the system and is filled as needed
from the bottom to the top, one element at a time. These elements can be
removed from the top to the bottom by removing one element at a time. That
is, the last element added to the stack is removed first.
• Heap- Heap is a contiguous block of memory that is available for use by the
program when need arise. A fixed size heap is allocated by the system and is
used by the system in a random fashion.
• When the program requests a block of memory, the dynamic allocation
technique carves out a block from the heap and assigns it to the program.
• When the program has finished using that block, it returns that memory block
to the heap and the location of the memory locations in that block is added to
the free list.

3
© Oxford University Press 2016. All rights reserved.
 UNDERSTANDING THE COMPUTER’S MEMORY contd.

• Global Memory- The block of code that is the main() program (along with other
functions in the program) is stored in the global memory. The memory in the global
area is allocated randomly to store the code of different functions in the program in
such a way that one function is not contiguous to another function. Besides, the
function code, all global variables declared in the program are stored in the global
memory area.
• Other Memory Layouts- C provides some more memory areas like- text segment,
BSS and shared library segment.
• The text segment is used to store the machine instructions corresponding to the
compiled program. This is generally a read-only memory segment
• BSS is used to store un-initialized global variables
• Shared libraries segment contains the executable image of shared libraries that are
being used by the program.
© Oxford University Press 2016. All rights reserved.
 INTRODUCTION
• Every variable in C has a name and a value associated with it. When a variable is
declared, a specific block of memory within the computer is allocated to hold the
value of that variable. The size of the allocated block depends on the type of the
data.
int x = 10;
• When this statement executes, the compiler sets aside 2 bytes of memory to hold
the value 10. It also sets up a symbol table in which it adds the symbol x and the
relative address in memory where those 2 bytes were set aside.
• Thus, every variable in C has a value and an also a memory location (commonly
known as address) associated with it. Some texts use the term rvalue and lvalue for
the value and the address of the variable respectively.
• The rvalue appears on the right side of the assignment statement and cannot be
used on the left side of the assignment statement. Therefore, writing 10 = k; is
illegal.
© Oxford University Press 2016. All rights reserved.
 DECLARING POINTER VARIABLES
• Actually pointers are nothing but memory addresses.
• A pointer is a variable that contains the memory location of another variable.
• The general syntax of declaring pointer variable is
data_type *ptr_name;
Here, data_type is the data type of the value that the pointer will point to. For
example:
int *pnum; char *pch; float *pfnum;
int x= 10;
int *ptr = &x;
The '*' informs the compiler that ptr is a pointer variable and the int specifies that it
will store the address of an integer variable.
The & operator retrieves the lvalue (address) of x, and copies that to the contents of
the pointer ptr.
© Oxford University Press 2016. All rights reserved.
 DE-REFERENCING A POINTER VARIABLE
• We can "dereference" a pointer, i.e. refer to the value of the variable to which it points by using
unary '*' operator as in *ptr. That is, *ptr = 10, since 10 is value of x.
#include<stdio.h>
int main()
{
int num, *pnum;
pnum = &num;
printf(“\n Enter the number : “);
scanf(“%d”, &num);
printf(“\n The number that was entered is : %d”, *pnum);
return 0;
}
OUTPUT:
Enter the number : 10
The number that was entered is : 10

© Oxford University Press 2016. All rights reserved.

 POINTER EXPRESSIONS AND POINTER ARITHMETIC
• Pointer variables can also be used in expressions. For ex,
int num1=2, num2= 3, sum=0, mul=0, div=1;
int *ptr1, *ptr2;
ptr1 = &num1, ptr2 = &num2;
sum = *ptr1 + *ptr2;
mul = sum * *ptr1;
*ptr2 +=1;
div = 9 + *ptr1/*ptr2 - 30;
• We can add integers to or subtract integers from pointers as well as to subtract one pointer from the
other.
• We can compare pointers by using relational operators in the expressions. For example p1 > p2 ,
p1==p2 and p1!=p2 are all valid in C.

© Oxford University Press 2016. All rights reserved.

• When using pointers, unary increment (++) and decrement
(--) operators have greater precedence than the dereference
operator (*). Therefore, the expression
• *ptr++ is equivalent to *(ptr++). So the expression will
increase the value of ptr so that it now points to the next
element.
• In order to increment the value of the variable whose address
is stored in ptr, write (*ptr)++

9
© Oxford University Press 2016. All rights reserved.
 NULL POINTERS
A null pointer which is a special pointer value that is known not to point anywhere.
This means that a NULL pointer does not point to any valid memory address.
To declare a null pointer you may use the predefined constant NULL,
int *ptr = NULL;
You can always check whether a given pointer variable stores address of some
variable or contains a null by writing,
if ( ptr == NULL)
{ Statement block;
}
Null pointers are used in situations if one of the pointers in the program points
somewhere some of the time but not all of the time. In such situations it is always
better to set it to a null pointer when it doesn't point anywhere valid, and to test to
see if it's a null pointer before using it.

© Oxford University Press 2016. All rights reserved.

 GENERIC POINTERS

• A generic pointer is pointer variable that has void as its data type.
• The generic pointer, can be pointed at variables of any data type.
• It is declared by writing
void *ptr;
• You need to cast a void pointer to another kind of pointer before using it.

© Oxford University Press 2016. All rights reserved.

• Generic pointers are used when a pointer has to point to data of different
types at different times. For ex,
#include<stdio.h>
main()
{ int x=10;
char ch = ‘A’;
void *gp;
gp = &x; printf("\n Generic pointer points to the integer value =
%d", *(int*)gp);
gp = &ch;
printf("\n Generic pointer now points to the character %c", *(char*)gp);
}
OUTPUT:
Generic pointer points to the integer value = 10
Generic pointer now points to the character = A
12
© Oxford University Press 2016. All rights reserved.
PASSING ARGUMENTS TO FUNCTION USING POINTERS

The calling function sends the addresses of the

variables and the called function must declare those
incoming arguments as pointers. In order to modify
the variables sent by the caller, the called function
must dereference the pointers that were passed to it.
Thus, passing pointers to a function avoid the
overhead of copying data from one function to
another.

© Oxford University Press 2016. All rights reserved.

#include<stdio.h>
main()
{
int num1, num2, total;
printf(“\n Enter two numbers : “);
scanf(“%d %d”, &num1, &num2);
sum(&num1, &num2, &total);
printf(“\n Total = %d”, total);
}
void sum ( int *a, int *b, int *t)
{
*t = *a + *b;
}

14
© Oxford University Press 2016. All rights reserved.