1

POINTERS
Pointer is a variable that contains the address
of an another variable.
A pointer is an address of a storage location,
By convention, zero represents the "null"
pointer.
The size of a pointer depends on the amount of
memory to be addressed.
By default pointer size is 2 bytes
A 16-bit pointer can address 64K locations.
A 32-bit pointer can address 4 trillion locations.
Pointer is used to access memory and
manipulate addresses.
Syntax: <datatype> *<pointer name>
Why use pointers?
Pointers can be used as variable length
arrays.
Pointers can be used for advanced data
structures.
Pointers can be "cheaper" to pass around a
program.
If we want to pass a huge struct or array, its
easier to pass a pointer than the whole thing.
In general, pointers allow cleaner, more
compact code.
Pointer Types
Wild pointers arise when a pointer is used prior to
initialization to some known state.
Null pointer is a pointer which points to no where.
Void Pointer is also called as a Generic Pointer,
which can store the address of any variable .
Dangling pointer (C++) arise when an object is
deleted or deallocated, without modifying the value
of the pointer, so that the pointer still points to the
memory location of the deallocated memory.
& - address of operator / referencing operator
* - value at address operator / Dereferencing
Operator.
4
Pointer Variables
int v; // defines variable v of type int
int w; // defines variable w of type int
int *p; // defines variable p of type pointer to int
p=&v; // assigns address of v to pointer p
v=3; // assigns value 3 to v
*p=7; // assigns value 7 to v
p=&w; // assigns address of w to pointer p
*p=12; // assigns value 12 to w

Using the indirection operator *p to access the
contents of a variable is called indirect addressing
or dereferencing the pointer

5
Examples of pointer declarations:
int *a;
float *b;
char *c;
FILE *fptr;
The asterisk, when used as above in the
declaration, tells the compiler that the variable
is to be a pointer, and the type of data that the
pointer points to, but NOT the name of the
variable pointed to.
6
Use of & and *
When is & used?

When is * used?

& -- "address operator" which gives or
produces the memory address of a data
variable.
* -- "dereferencing operator" which provides
the contents in the memory location
specified by a pointer
Permissible operations with pointers
Adding a value to the pointer
Subtracting a value from the pointer
Incrementing a pointer
Decrementing a pointer

Not-permissible operations with pointers
Two pointers cant be added.
Multiplication, Division cant be done between
any two pointers.

Wap to find pointer Addition
#include<stdio.h>
main()
{
int a,b,c,*p,*q;
clrscr();
printf ("Enter a,b values:");
scanf ("%d%d", &a, &b);
p=&a;
q=&b;
c=*p+*q;
printf("Addition=%d", c);
getch();
}
#include<stdio.h>
main()
{ int a,b,c,d,e,f,*p,*q;
clrscr();
printf("Enter a,b values:");
scanf("%d%d",&a,&b);
p=&a;
q=&b;
c=--*q;
d=*q--;
e=++*p;
f=*p++;
printf("\n pre decrement=%d", c);
printf("\n post decrement=%d", d);
printf("\n pre increment=%d", e);
printf("\n post increment=%d", f);
getch();
}
Wap to print address of the pointers
#include<stdio.h>
main()
{
int a,b,c,*p,*q;
clrscr();
printf("Enter a,b values:");
scanf("%d%d",&a,&b);
p=&a;
q=&b;
printf("Pointers Address=%u %u",p,q);
printf(\n Pointer values =%d %d,a,b);
getch();
}
WHAT IS OUTPUT OF THIS PGM
#include <stdio.h>
int main()
{
int i,j;
int *p; /* a pointer to an integer */
p = &i;
*p=5;
j=i;
printf("%d %d %d\n", i, j, *p);
getch();
}

12
*/Factorial of a given number using pointers*/
main()
{ int n,factorial;
printf(enter a number);
scanf(%d,&n);
factcompute(n,&factorial);
printf(the factorial of %d,n,factorial);
}
factcompute(a,b)
int a,*b;
{
int m; *b=1;
for(m=1;m<=a;m++)
*b=*b*m;
}


Wap to swap numbers using third variable
#include<stdio.h>
main()
{
int *p,*q,a,b,temp;
clrscr();
printf("Enter a,b values:");
scanf("%d%d",&a,&b);
p=&a;
q=&b;
temp=*p;
*p=*q;
*q=temp;
printf("After Swapping a=%d b=%d",a,b);
getch();
}
Wap to swap numbers without using third variable
#include<stdio.h>
main()
{
int *p,*q,a,b,temp;
clrscr();
printf("Enter a,b values:");
scanf("%d%d",&a,&b);
p=&a;
q=&b;
*p=*p + *q;
*q=*p - *q;
*p=*p - *q;
printf("After Swapping a=%d b=%d",a,b);
getch();
}
15
Pointers as Function Arguments
Call by reference for arguments that may be altered
by the function.
Call by value is appropriate for small arguments
that should not be altered by the function.
Call by constant reference for large arguments that
should not be altered by the function
by value : void f(int x);
by reference : void f(int* x);
In pass-by-value the function obtains only a local
copy of the variable, so that changes to the local
variable have no impact on the argument with
which the function was invoked.
In pass-by-reference the function manipulates the
original variable rather than merely its copy
16
Pass-by-Reference
void swap( double* ptr1, double* ptr2)
{
double tmp=*ptr1;
*ptr1=*ptr2; /* de-referencing pointer */
*ptr2=tmp;
}
int main()
{
double a=3.0;
double b=5.0
swap(&a, &b); /* call by reference using the addresses of a and b */
printf(a=%lf, b=%lf\n, a,b);
}
Pointers to Pointers
It is possible and often useful to create
pointers to pointers.
This technique is sometimes called a handle,
and is useful in certain situations where the
operating system wants to be able to move
blocks of memory on the heap around at its
discretion.
The following example demonstrates a
pointer to a pointer:
int **p;
int *q;
p = (int **)malloc(sizeof(int *));
*p = (int *)malloc(sizeof(int));
**p = 12;
q = *p;
printf("%d\n", *q);
free(q);
free(p);
Memory Allocation
1. malloc allocates memory, void *malloc(size_t size)
returns a pointer to a chunk of memory which is the
size in bytes requested.
2. calloc allocates and clears a two-dimensional chunk
of memory, void *calloc(size_t nmemb, size_t size)
same as malloc but puts zeros in all bytes and asks
for the number of elements and size of an element.
3. free returns previously allocated memory to the
operating system, void free(void *ptr) deallocates a
chunk of memory. Acts much like the delete operator.
4. realloc changes the size of previously allocated
memory, void *realloc(void *ptr, size_t size) changes
the size of the memory chunk point to by ptr to size
bytes, prototypes found in the stdlib.h header file.
Example Memory Allocation
void main()
{
char *cptr;
double *dblptr;
struct Student *stuptr;
/* equiv to cptr = new char[100]; */
cptr = (char *) malloc(100);
/* equiv to dlbptr = new double[100]; */
dblptr = (double *) malloc(sizeof(double) * 100);
/* equiv to stuptr = new Student[100]; */
stuptr = (struct Student *) malloc( sizeof( struct
Student) * 100);
}

Advantages of Pointers:
Makes program works faster as they are directly dealing with
addresses.
Arrays can be easily accessed using pointers
Call by Reference can be achieved using Pointers
Dynamic memory allocation can be achieved
Complex Declarations are possible in Pointers.
Passing arguments to functions when the function needs to
modify the original argument.
Passing arrays and strings to functions
Obtaining memory from the system
Creating data structures such as linked lists.
Function cannot return more than one value. But when the same
function can modify many pointer variables and function as if it
is returning more than one variable.
In the case of arrays, we can decide the size of the array at
runtime by allocating the necessary space.
Disadvantages
Pointers are probably the single largest
source of bugs in software, so be careful
anytime you deal with them.
Dangling reference (premature free)
Memory leaks (tardy free).
If sufficient memory is not available during
runtime for the storage of pointers, the
program may crash (least possible).