Pointers-Computer programming

Ramesh Bandaru Page 1
Pointers
A pointer is a memory variable that stores a memory address. Pointer can have any name that is legal fro
other variable and it is declared in the same fashion like other variables but it is always denoted by ‘*’ operator.
Features
1. Pointers save the memory space.
2. Execution time with pointer is faster because data is manipulated with the address i.e. direct access to
memory location.
3. Pointers reduce the length and complexity of a program.
4. The memory is accessed efficiently with the pointers. The pointer assigns the memory space and it also
releases. Dynamically memory is allocated.
5. Pointers are used with data structures. They are useful for representing tow-dimensional and multi
dimensional arrays, structures.
Pointer Declaration
The declaration of pointer is as follows
data type *pt_name;
This tells the compiler three things about the variable pathname
1. The asterisk (*) tells that the variable pt_name is a pointer variable.
2. pt_name needs a memory location.
3. pt_name points to variable of type data type
Example: int *p;
In the above example, the variable p as a pointer variable that points to an integer data type. Remember that the type
int refers to the data type of the variable being pointed to by p and not the type of the value of the pointer. Similarly,
the following declares character and floating pointers.
char *ch;
float *x;
Once the pointer variable is declared, it can be made to a point to a variable using an assignment statement.
Accessing the Address of a Variable
The actual location of a variable in the memory is system dependent and therefore, the address of a variable
is not known to us immediately. The address can be known with help of operator & available in C. The operator &
immediately preceding a variable returns the address of the variable associated with it.
Example : &a;
would give the address of variable location. The & operator can be used only with simple variable or an array
elements. If x is an array, then expressions
&x[0] , &x[i+3]

Initializing a Pointer
After declaration of pointer, it can be initialized with an address of another variable. The assignment statement
is as follows
int *p, a;
p = &a;
In the above statements, a is an integer variable. p is a integer pointing variable.i.e. &a gets the address of variable a
and assigns to the pointer variable p.
Accessing a variable through its Pointer
Once the pointer has been assigned address of a variable, accessing the value of the variable using the
pointer is important. This is done y using unary operator * (asterisk), usually known as the indirection operator.
Ex. int a, *p, n;
a = 10;
p = &a;
n = *p;
The first line declares integer variables a and n, also declares a pointer variable p. Second line assigns value 10 to
the variable a. Third line gets the address of variable of a and stores in the value in pointer p. Fourth line access the
value of a with help of pointer p and stores in variable n.
/*Program to demonstrate the accessing of pointer*/
#include <graphics.h>
void main()
{
int x,y, *ptr;
clrscr();
x=10;
ptr=&x;
y=*ptr;
printf("Value of x = %d",x);
printf("nAddress of x = %u",&x);
printf("nValue stored pointer = %u",ptr);
printf("nAccessed value by pointer = %d",*ptr);
printf("nAddress of pointer = %u",&ptr);
printf("nValue of y = %d",y);
getch();
}
Output
Value of x = 10
Address of x = 65524
Value stored in pointer = 65524
Accessed value by pointer = 10
Address of pointer = 65520
Value of y = 10

Pointers for Inter Function Communication
In upward communication and bi-directional communication address is being passed and using this address
the data is referred back to the calling program. When we pass an address, we are actually passing a pointer to a
variable.
Passing Addresses
Rather than passing data to the called function, we pass addresses (pointers). Once we have a pointer to a
variable, it doesn’t make any difference if it is local to the active function, defined in main, or even if it is a global
variable – we can change it.
To create the pointers, the address operator(&) is used in the function call. To pass addresses, the formal
parameters in the called function are defined as pointer to variables.
Every time we want a called function to have access to a variable in the calling function, we pass the address
of that variable to the called function and indirection operator is used to access it.
/* Program to exchange two numbers using functions*/
void xChange(int*,int*);
void main()
{
int a,b;
clrscr();
printf("Enter two numbers :”);
scanf(“%d%d”,&a,&b);
printf(“nBefore Function : a = %d, b= %d”,a,b);
xChange(&a,&b);
printf("nAfter Function : a = %d, b = %d",a,b);
}
void xChange(int *x, int *y)
{
int temp;
printf("nIn function before operation: *x = %d, *y = %d",*x,*y);
temp = *x;
*x = *y;
*y = temp;
printf("nIn function after operation: *x = %d, *y = %d ",*x,*y);
}
Output:
Enter two numbers : 44 55
Before Function : a = 44, b = 55
In function before operation : *x = 44, *y = 55
In function after operation : *x = 55, *y = 44
After Function : a = 55 , b = 44
Functions returning Pointers
Nothing prevents a function from returning a pointer to the calling function. When we return a pointer, it must
point to data in the calling function or a higher level function. It is an error to return a pointer to a local variable in the
called function, because when the function terminates its memory may be used by other parts of the program.
/*Program to find smallest of two numbers using function returning pointers*/
int* smaller(int* , int*);
void main()
{
int a,b,*p;
printf(“Enter values of a and b :”);
scanf(“%d%d”,&a,&b);

p = smaller(&a, &b);
printf(“Smaller number = %d”,*p);
}
int* smaller(int* px, int* py)
{
return ( *px < *py ? px : py);
}
Output :
Enter values of a and b : 67 89
Smallest number = 67
Pointers to Pointers
A pointer to a pointer in C can be used to indirectly point to the memory address of a variable. A pointer is a
variable that contains the address of another variable. As a result, pointer to pointer contains the memory address of a
pointer, which holds the memory address of a variable. The declaration is done as follows
Data type **pointer name
Ex : int **ptr;*p, a=10;
p = &a;
ptr = &p;
In the above example, a is a normal variable storing the value 10. p is a pointer variable which stores the address of a
and ptr is the pointer to pointer which stores the address of pointer p.
/*Program to demonstrate the usage of pointers to pointers*/
#include<stdio.h>
void main()
{
int a=10,*ptr1,**ptr2;
clrscr();
ptr1 = &a;
ptr2 = &ptr1;
printf("na= %d",a);
printf("n&a = %u",&a);
printf("nptr1 = %u",ptr1);
printf("n*ptr1 = %d",*ptr1);
printf("n&ptr1 = %u",&ptr1);
printf("nptr2 = %u",ptr2);
printf("n*ptr2 = %u",*ptr2);
printf("n**ptr2 = %d",**ptr2);
getch();
}
Output
a = 10
&a = 65524
ptr1 = 65524
*ptr1 = 10
&ptr1 = 65522
ptr2 = 65522
*ptr2 = 65524
**ptr2 = 10
Compatibility
Pointers have a type associated with them. They are no just pointer types, but rather are pointers to a specific
type. Each pointer therefore takes on the attributes of the type to which it refers in addition to its own attributes.

Pointer Size Compatibility
The size of all pointers is the same. Every pointer variable holds the address of one memory location in the
computer. The size of the variable that the pointer references can be different; it takes the attributes of the type being
referenced.
All computers today have more than 65,535 bytes, which is the maximum address that could be stored in 2
bytes. So pointers size is 2 bytes in this case.
Dereference Type Compatibility
The deference type is the type of the variable that the pointer is referencing. With one exception, it is invalid
to assign a pointer of one type to a pointer of another type, even thought he values in both cases are memory
addresses and would therefore seem to be fully compatible. Although addresses may be compatible because they are
drawn from the same set, what is not compatible is the underlying data type of the referencing object.
In C we can’t use the assignment operator with pointers to different types. If we try to, we get compile error.
Ex: A pointer to char is only compatible with pointer to char and a pointer to an int is only compatible with pointer to int.
We cannot assign a pointer to a char to a pointer to an int.
A pointer to void is a generic type that is not associated with a reference type; that is, it is not the address of a
character, an integer, a real or any other type. So, it is compatible for assignment purpose only with all the other
pointer types. Thus, a pointer of any reference type can be assigned to a pointer to void type and a pointer to void
pointer can be assigned to pointer of any reference type.
Ex : void* ptr;
Casting Pointers
The problem of type incompatibility can be solved using casing. We can make an explicit assignment between
incompatible pointer types by using a cast, just as we can cast int to char. Another use of the cast is to provide a type
for void pointer. When we cast it, however, we provide the type.
Ex: void* ptr;
char* cptr;
int* iptr;
ptr = cptr;
iptr = ptr;
iptr = (int*) cptr;
Note : Compatibility also includes dereference level compatibility. Ex: a pointer to int is not compatible with a pointer-
to-pointer to int.
Pointer Expressions
Like other variables pointer variables can also be used in expressions. If p1 and p2 are properly declared and
initialized pointers, then the following expressions are valid
*p1 * *p2 (Performs multiplication of values accessed by pointer variables)
*p1 / *p2 (Performs division of values accessed by pointer variables)
*p1 > *p2 (Checks whether the first value accessed is greater than second variable accessed) etc.

/*Program to demonstrate pointers and expressions*/
#include <stdio.h>
void main()
{
int a=12, b=4, *p1, *p2;
clrscr();
p1=&a;
p2=&b;
printf(" *p1 + *p2 = %d",*p1+*p2);
printf("n*p1 - *p2 = %d",*p1-*p2);
printf("n*p1 * *p2 = %d",*p1* *p2);
printf("n*p1/*p2 = %d",*p1/ *p2);
if(*p1 > *p2)
printf("n*p1=%d value is greater",*p1);
else
printf("n*p2=%d value is greater",*p2);
getch();
}
Output
*p1 + * p2 = 16
*p1 - *p2 = 8
*p1 * *p2 = 48
*p1 / *p2 = 3
*p1 =12 is greater
Pointer Increments and Scale Factor
Let us consider an expression like
p++;
will cause the pointer p to point to the next value of its type. For example p is an integer pointer with an initial value,
say 6500, then after the operation
p++ i.e. p = p+1,
the value of p will be 6502, but not 6501. That is, when we increment a pointer, its value is increased by the length of
the data type that points to. This is called scale factor.
The number of bytes used to store various data types depends on the system and can be found by making
use of the sizeof operator. Generally, the character (1 byte), integer (2 bytes), float ( 4 bytes) etc.
Pointer and Arrays
When we declare an array, the compiler allocates a base address and sufficient amount of storage to contain
all the elements of the array in the contiguous memory locations. The base address is the location of first element
(index 0) of an array. The compiler also defines the array name as a constant pointer to first element. For example if
we consider
int x[10];
here, x is an integer array. The base address will be the address of x[0]. As per the compiler the name x is defined as
constant pointer pointing to the first element x[0] and therefore
x = &x;
If we declare a pointer p as an integer pointer, then we can make the pointer p to point to array x by the following
statement
int x[10], *p;
p = x; (this is equivalent to p = &x[0]);
Now we can access every value of x by using p++ to move from one element to another . Like
p = &x[0] (=6500)
p+1 = &x[1] (=6502)

p+2 = &x[2] (=6504)
Instead of using array indexing, we can use pointers to access array elements. *(p+2) gives the value stored
in x[2].. The pointer accessing method is much faster than array indexing.
It is possible to avoid the loop control variable i as shown below
p = x;
while (p <= p+4)
{
Sum = sum + *p;
p++;
}
We know that in one dimensional array x, the expression
x[i] is equivalent to *(p+i)
Pointers can be used to manipulate two-dimensional arrays as well.
x[i][j] is represented as *(*(p+i)+j)
The base address of the array &x[0][0] , the compiler allocates contiguous space for all elements row-wise.
/*Program to demonstrate pointer and arrays */
#include<stdio.h>
void main()
{
int a[5], *p, sum=0, i;
clrscr();
p=a;
printf("Enter 5 numbers :");
for(i=0; i<5; i++)
{
scanf("%d",p+i);
sum = sum + *(p+i);
}
printf("Sum = %d", sum);
getch();
}
Output
Enter 5 numbers : 1 2 3 4 5
Sum = 15
Passing an array to a function
The name of an array is actually a pointer to the first element, so in a function call sending an array we send
array name instead of address for processing. When we pass the array, we do not use the address operator.
Remember, the array name is pointer constant, so the name is already the address of the first element in array
Ex :
int doIt(int[]);
void main()
{
int arrName[100];
---------;
doIt(arrName);
}
int doIt(int* arrSalary)
{
------------;
}

Memory Allocation Functions
In C, reserving memory locations for an object can be done in two ways : static allocation and dynamic
allocation.
Memory Usage
Conceptually memory is divided into program memory and data memory. Program memory consists of the
memory used for main and functions. Data memory consists of permanent definitions, such as global data and
constants, local declarations and dynamic data memory. Exactly how C handles these different needs is a function of
operating system and the compiler writer’s skills.
Although the program code for a function may be in memory at all times, the local variables for function are
available only when it is active. Furthermore, more than one version of the function can be active at a time. In this
case, multiple copies of the local variables are allocated, although only one copy of the function is present. The
memory facility for these capabilities is known as stack memory.
In addition to stack, a memory allocation known as heap is available. Heap memory is unused memory
allocated to the program and available to be assigned during its execution. It is the memory pool from which memory
is allocated when requested by the memory allocation functions.
Main Function
Program Memory
Global Heap Stack
Data Memory
Conceptual View of Memory
Static Memory Allocation
Static memory allocation requires that the declaration and definition of memory be fully specified in the source
program. The number of bytes reserved cannot be changed during run time. This is the technique we have used to
this point to define variables, arrays, pointers, and streams.
Dynamic Memory Allocation
Dynamic memory allocation uses predefined functions to allocate and release memory for data while the
program is running. It effectively postpones the data definition, but not the data declaration, to run time.
Memory Allocation Functions
Four memory management functions are used with dynamic memory. They are malloc, calloc, realloc and
free. First three are used for memory allocation and fourth is used for return memory when it is no longer needed. All
the memory management functions are found in the standard library file stdlib.h.

Block Memory Allocation (malloc)
The malloc function allocates a block of memory that contains the number of bytes specified in its parameters.
It returns a void pointer to the first byte of the allocated memory. The allocated memory is not initialized.
Function prototype is
void* malloc(size_t size);
The type, size_t is defined in several header files including stdio.h. The type is usually an unsigned integer.
To provide portability, the size specification in malloc’s actual parameter is generally computed using the
sizeof operator. For example, if we want to allocate an integer in the heap, then we call as follows
pInt = malloc(sizeof(int));
malloc function returns the address of the first byte in the memory space allocated. If it is not successful, it
return NULL pointer. An attempt to allocate memory from the heap when the memory is insufficient is known as
overflow. It is up to the program to check for memory overflow. If it doesn’t the program produces the invalid results
or aborts with an invalid address the first time the pointer is used.
If we call malloc with a zero size, the results are unpredictable. It may return NULL pointer or it may return
some other implementation dependent value.
Note : Never call malloc with a zero size
Prior to C99, it was necessary to cast the pointer returned from a memory allocation function. The casting
format is
pointer = (type*) malloc(size);
Ex: pInt = (int*)malloc(4);
Contiguous Memory Allocation (calloc)
calloc is primarily used to allocate memory for arrays. It differs from malloc only in that it sets memory to null
characters. The declaration is as follows
void *calloc(size_t element_count, size_t element_size);
Example :
ptr = (int*) calloc(200, sizeof(int));
Reallocation of memory (realloc)
It is highly efficient function. When given a memory pointer to a previously allocated block of memory, realloc changes
the size of the block by deleting or extending the memory at the end of block. If the memory cannot be extended
because of other allocations, realloc allocates a completely new block, copies the existing memory allocation to the
new allocation and deletes the old allocation. The declaration is as follows
void *realloc(void* ptr, size_t newSize);
Example
ptr = realloc(ptr, 15*sizeof(int));

Releasing Memory (free)
When memory locations allocated by malloc, calloc or realloc are no longer needed, they should be freed
using predefined function free. It is an error to free memory with a null pointer, a pointer to other than the first element
of an allocated bloc, a pointer that is a different type than the pointer that allocated the memory, it is also a potential
error to refer to memory after it has been released. The function declaration is
void free(void* ptr);
Example
free(ptr);
Releasing memory does no change the value in the pointer. It still contains the address in the heap. It is logic error to
use the pointer after memory has been released.
Note : The pointer used to free memory must be of the same type as the pointer used to allocate memory.
Pointers to Void and Functions
Pointer to void
A pointer to void is a generic pointer that can be used to represent any data type during compilation or run
time. Note that a pointer to void is not a null pointer; it is pointing to a generic data type (void).
Example:
/* Program to demonstrate pointer to void*/
#include<stdio.h>
void main()
{
void* p;
int i=7;
float f=23.5;
p=&i;
printf(“ i contains : %dn”, *((int*)p));
printf(“ f contains : %fn”,*((float*)f));
}
Output
i contains 7
f contains 23.500000
Note : A pointer to void cannot be dereferenced unless it is cast.
Pointer to Function
A function, like a variable, has an address location in the memory. It is therefore, possible to declare a pointer
to function, which can then be used as an argument in another function. A function to a pointer is declared as follows:
type (fptr)();
This tells the compiler that fptr is a pointer to a function which returns type value. Example
double (*p1)(), mul();
p1 = mul;
The above statement declares p1 as a pointer to a function and mul as a function and then make p1 to point to the
function mul.
Command Line Arguments
When main have parameters, they are known as command line arguments. The function main can be defined
either with no argument (void) or with two arguments : one an integer and other an array of pointers to char (strings)
that represent user-determined values to be passed to main. The two different formats are
1. void main()

{
-----;
}
2. void main(int argc, char *argv[])
{
-----
}
The names of the arguments are our choice, traditionally they are called argc(argument count) and argv (argument
vector). The first argument defines the number of elements in the array identified in the second argument. The value
for this argument is not entered using the keyboard; the system determines it from the arguments the user types.
The argc array has several elements. The first element points to the name of the program (its filename). It is
provided automatically by the program. The last element contains NULL and may be used to identify the end of the
list. The rest of the elements contain pointers to the user-entered string values.
/* Program to demonstrate command line arguments*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void main(int argc, char* argv[])
{
int i;
printf(“The number of arguments = %dn”,argc);
printf(“The name of the program = %sn”,argv[0]);
for(i=1; i<argc; i++)
printf(“User value No. %d= %sn”,i,argv[i]);
}
Output
C:/> cmdLine it is the time
The number of arguments =5
The name of the program = CMDLINE
User value No.1 = it
User value No.2 = is
User value No.3 = the
User value No.4 = time
-o0o-

Pointers-Computer programming

Recommended

More Related Content

What's hot (20)

Similar to Pointers-Computer programming (20)

More from nmahi96 (20)

Recently uploaded (20)

Pointers-Computer programming