Pointers in C

Definition
A Pointer is a variable that holds address
of another variable of same data type.
also known as locator or indicator that
points to an address of a value.
Benefits of using pointers
Pointer reduces the code and improves the
performance, it is used to retrieving
strings, trees etc. and used with arrays,
structures and functions.
We can return multiple values from
function using pointer.
 It makes you able to access any memory
location in the computer's memory.
It allows C to support dynamic memory
management.
Concept of pointer
Whenever a variable is declared in the program,
system allocates a location i.e a name to that
variable in the memory, to hold the assigned
value. This location has its own address number.
Let us assume that system has allocated memory
location 80F for a variable a.
int a = 10 ;
 We can access the value 10 by either using the
variable name a or the address 80F. Since the
memory addresses are simply numbers they can be
assigned to some other variable. The variable that
holds memory address are called pointer variables.
A pointer variable is therefore nothing but a
variable that contains an address, which is a location
of another variable. Value of pointer variable will
be stored in another memory location.
Declaring a pointer variable

General syntax of pointer declaration is,

Data type of a pointer must be same as

the data type of a variable to which the
pointer variable is pointing. void type
pointer works with all data types, but is
not used often used.
Initialization of Pointer variable

Pointer Initialization is the process of

assigning address of a variable
to pointer variable. Pointer variable contains
address of variable of same data type.
In C language address operator & is used
to determine the address of a variable.
The & (immediately preceding a variable
name) returns the address of the variable
associated with it.
Pointer variable always points to same type of data.

Note: If you do not have an exact address to be

assigned to a pointer variable while declaration, It is
recommended to assign a NULL value to the pointer
variable. A pointer which is assigned a NULL value is
called a null pointer.
Dereferencing of Pointer

Once a pointer has been assigned the

address of a variable. To access the value
of variable, pointer is dereferenced, using
the indirection operator *.
Points to remember:
While declaring/initializing the pointer
variable, * indicates that the variable is a pointer.
The address of any variable is given by preceding
the variable name with Ampersand '&'.
The pointer variable stores the address of a variable.
The declaration int *a doesn't mean that a is going
to contain an integer value. It means that a is going
to contain the address of a variable storing integer
value.
To access the value of a certain address stored by a
pointer variable, * is used. Here, the * can be read
as 'value at'.
A Simple program to explain pointers:
Pointer Arithmetic
16 bit Machine ( Turbo C )
In a 16 bit machine, size of all types of
pointer, be
it int*, float*, char* or double* is always 2
bytes.
But when we perform any arithmetic
function like increment on a pointer,
changes occur as per the size of their
primitive data type.
Examples for Pointer Arithmetic

In the above case, pointer will be of 2 bytes. And when we increment it, it
will increment by 2 bytes because int is also of 2 bytes.

In this case, size of pointer is still 2 bytes. But now, when we increment it,
it will increment by 4 bytes because float is of 4 bytes.

Similarly, in this case, size of pointer is still 2 bytes. But now, when we
increment it, it will increment by 8 bytes because its data type is double.
32 bit Machine (Visual Basic C++)

The concept of pointer arithmetic remains

exact same, but the size of pointer and
various datatypes is different in a 32 bit
machine. Pointer in 32 bit machine is of
4 bytes.
And,following is a table for Size of datatypes on 32-bit
Machine :

Note: We cannot add two pointers. This is because

pointers contain addresses, adding two addresses makes
no sense, because you have no idea what it would point
to.But we can subtract two pointers.This is because
difference between two pointers gives the number of
elements of its data type that can be stored between the
two pointers.
Program for pointer arithmetic(32-bit machine)
Explanation of the above program:
Point 1: Here, * means 'value at the given address'.
Thus, it adds the value of m and n which is 15.
Point 2: It subtracts the addresses of the two variables
and then divides it by the size of the pointer datatype
(here integer, which has size of 4 bytes) which gives
us the number of elements of integer data type that can
be stored within it.
Point 3: It increments the address stored by the
pointer by the size of its datatype(here 4).
Point 4: It decrements the address stored by the
pointer by the size of its datatype(here 4).
Point 5: Addition of two pointers is not allowed.
Pointer and Arrays
When an array is declared, compiler
allocates sufficient amount of memory to
contain all the elements of the array. Base
address i.e address of the first element of
the array is also allocated by the compiler.
Suppose we declare an array arr,
Assuming that the base address of arr is 1000 and each
integer requires two bytes, the five elements will be stored
as follows:

Here variable arr will give the base address, which is a

constant pointer pointing to the element, arr[0].
Therefore arr is containing the address of arr[0] i.e 1000.
In short, arr has two purpose - it is the name of an array and
it acts as a pointer pointing towards the first element in the
array.

arr is equal to &arr[0] //by default

We can declare a pointer of type int to
point to the array arr.

Now we can access every element of

array arr using p++ to move from one
element to another.
NOTE : You cannot decrement a pointer
once incremented. p-- won't work.
Example
void main()
{
int x[5]={2,4,6,8,10},i=0;
clrscr();
printf(“\nElement Number Element Address”);
while(i<5)
{
printf(“\nx[%d] = \t%d %u”,i,*(x+i),x+i);
i++;
}
Output
Element Number Element Address
X[0]= 2 4056
X[1]= 4 4058
X[2]= 6 4060
X[3]= 8 4062
X[4]= 10 4064
Pointer to Array
we can use a pointer to point to an Array, and
then we can use that pointer to access the
array.
 Example:

In the above program, the pointer *p will print

all the values stored in the array one by one.
We can also use the Base address (a in above
case) to act as pointer and print all the values.
The generalized form for using pointer
with an array,

is same as:
Array of pointers
Example, which uses an array of 3 integers −

When the above code is compiled and

executed, it produces the following result −
There may be a situation when we want to
maintain an array, which can store
pointers to an int or char or any other data
type available. Following is the
declaration of an array of pointers to an
integer −

It declares ptr as an array of MAX

integer pointers. Thus, each element in
ptr, holds a pointer to an int value.
The following example uses three integers,
which are stored in an array of pointers, as
follows −

When the above code is compiled and executed,

it produces the following result −
Pointers to Function
It is possible to declare a pointer pointing
to a function which can then be used as an
argument in another function. A pointer to
a function is declared as follows,
A function pointer can point to a specific
function when it is assigned the name of
the function.

s isa pointer to a function sum.

Now sum can be called using function
pointer s with the list of parameter.
Example of Pointer to Function