Pointers
in ‘C’ Language:
Introduction:
In C, a pointer is a variable that points to or references a memory location
in which data is stored. Each memory cell in the computer has an address that
can be used to access that location so a pointer variable points to a memory
location we can access and change the contents of this memory location via the
pointer.
Pointer declaration:
A pointer is a variable that contains the memory location of another
variable. The syntax is as shown below. You start by specifying the type of
data stored in the location identified by the pointer. The asterisk tells the
compiler that you are creating a pointer variable. Finally you give the name of
the variable.
type * variable name
Example:
int *ptr;
float *string;
Address operator:
Once we declare a pointer variable we must point it to something we can do
this by assigning to the pointer the address of the variable you want to point
as in the following example:
ptr=#
This places the address where num is stores into the variable ptr. If num is
stored in memory 21260 address then the variable ptr has the value 21260.
/* A program to illustrate pointer declaration*/
main()
{
int *ptr;
int sum;
sum=45;
ptr= ∑
printf (“\n Sum is %d\n”, sum);
printf (“\n The sum pointer is %d”, ptr);
}
we will get the same result by assigning the address of num to a regular(non
pointer) variable. The benefit is that we can also refer to the pointer
variable as *ptr the asterisk tells to the computer that we are not interested
in the value 21260 but in the value stored in that memory location. While the
value of pointer is 21260 the value of sum is 45 however we can assign a value
to the pointer * ptr as in *ptr=45.
This means place the value 45 in the memory address pointer by the variable
ptr. Since the pointer contains the address 21260 the value 45 is placed in
that memory location. And since this is the location of the variable num the
value also becomes 45. this shows how we can change the value of pointer
directly using a pointer and the indirection pointer.
/*
Program to display the contents of the variable their address using pointer
variable*/
#include< stdio.h >
{
int num, *intptr;
float x, *floptr;
char ch, *cptr;
num=123;
x=12.34;
ch=’a’;
intptr=&x;
cptr=&ch;
floptr=&x;
printf(“Num %d stored at address %u\n”,*intptr, intptr);
printf(“Value %f stored at address %u\n”,*floptr, floptr);
printf(“Character %c stored at address %u\n”,*cptr, cptr);
}
Pointer expressions & pointer arithmetic:
Like other variables pointer variables can be used in expressions. For
example if p1 and p2 are properly declared and initialized pointers, then the
following statements are valid.
y=*p1**p2;
sum=sum+*p1;
z= 5* - *p2/p1;
*p2= *p2 + 10;
C allows us to add integers to or subtract integers from pointers as well as
to subtract one pointer from the other. We can also use short hand operators
with the pointers p1+=; sum+=*p2; etc.,
we can also compare pointers by using relational operators the expressions
such as
p1 >p2 , p1==p2 and p1!=p2 are allowed.
/*Program to illustrate the pointer expression and pointer arithmetic*/
#include< stdio.h >
main()
{
int ptr1,ptr2;
int a,b,x,y,z;
a=30;b=6;
ptr1=&a;
ptr2=&b;
x=*ptr1+ *ptr2 –6;
y=6*- *ptr1/ *ptr2 +30;
printf(“\nAddress of a +%u”,ptr1);
printf(“\nAddress of b %u”,ptr2);
printf(“\na=%d, b=%d”,a,b);
printf(“\nx=%d,y=%d”,x,y);
ptr1=ptr1 + 70;
ptr2= ptr2;
printf(“\na=%d, b=%d”,a,b);
}
Pointers and function:
The pointer are very much used in a function declaration. Sometimes only
with a pointer a complex function can be easily represented and success. The
usage of the pointers in a function definition may be classified into two
groups.
1. Call by reference
2. Call by value.
Call by value:
We have seen that a function is invoked there will be a link established
between the formal and actual parameters. A temporary storage is created where
the value of actual parameters is stored. The formal parameters picks up its
value from storage area the mechanism of data transfer between actual and
formal parameters allows the actual parameters mechanism of data transfer is
referred as call by value. The corresponding formal parameter represents a
local variable in the called function. The current value of corresponding
actual parameter becomes the initial value of formal parameter. The value of
formal parameter may be changed in the body of the actual parameter. The value
of formal parameter may be changed in the body of the subprogram by assignment
or input statements. This will not change the value of actual parameters.
/* Include< stdio.h >
void main()
{
int x,y;
x=20;
y=30;
printf(“\n Value of a and b before function call =%d %d”,a,b);
fncn(x,y);
printf(“\n Value of a and b after function call =%d %d”,a,b);
}
fncn(p,q)
int p,q;
{
p=p+p;
q=q+q;
}
Call by Reference:
When we pass address to a function the parameters receiving the address
should be pointers. The process of calling a function by using pointers to pass
the address of the variable is known as call by reference. The function which
is called by reference can change the values of the variable used in the call.
/* example of call by reference*/
/* #Include< stdio.h >
void main()
{
int x,y;
x=20;
y=30;
printf(“\n Value of a and b before function call =%d %d”,a,b);
fncn(&x,&y);
printf(“\n Value of a and b after function call =%d %d”,a,b);
}
fncn(p,q)
int p,q;
{
*p=*p+*p;
*q=*q+*q;
}
Reference :
http://www.exforsys.com/tutorials/c-language/c-pointers.html
