GE6151 Computer Programming POINTERS

POINTERS Definition:

§ C Pointer is a variable that stores/points the address of the another variable.

§ C Pointer is used to allocate memory dynamically i.e. at run time.

§ The variable might be any of the data type such as int, float, char, double, short etc.

§ Syntax : data_type *var_name; Example : int *p; char *p;

Where, * is used to denote that “p” is pointer variable and not a normal variable.

Key points to remember about pointers in C:

§ Normal variable stores the value whereas pointer variable stores the address of the variable.

§ The content of the C pointer always be a whole number i.e. address.

§ Always C pointer is initialized to null, i.e. int *p = null.

§ The value of null pointer is 0.

§ & symbol is used to get the address of the variable.

§ * symbol is used to get the value of the variable that the pointer is pointing to.

§ If pointer is assigned to NULL, it means it is pointing to nothing.

§ The size of any pointer is 2 byte (for 16 bit compiler).

§ No two pointer variables should have the same name.

§ But a pointer variable and a non-pointer variable can have the same name.

4.4.1 Pointer –Initialization:

Assigning value to pointer:

It is not necessary to assign value to pointer. Only zero (0) and NULL can be assigned to a pointer no other number can be assigned to a pointer. Consider the following examples;

int *p=0;

int *p=NULL; The above two assignments are valid. int *p=1000; This statement is invalid.

Assigning variable to a pointer:

int x; *p;

p = &x;

This is nothing but a pointer variable p is assigned the address of the variable x. The address of the variables will be different every time the program is executed.

Reading value through pointer:

int x=123; *p;

p = &x;

Here the pointer variable p is assigned the address of variable x. printf(“%d”, *p); will display value of x 123. This is reading value through pointer printf(“%d”, p); will display the address of the variable x.

printf(“%d”, &p); will display the address of the pointer variable p.

printf(“%d”,x); will display the value of x 123.

printf(“%d”, &x); will display the address of the variable x.

Note: It is always a good practice to assign pointer to a variable rather than 0 or NULL.

Pointer Assignments:

We can use a pointer on the right-hand side of an assignment to assign its value to another variable.

Example:

int main()

{

int var=50; int *p1, *p2; p1=&var; p2=p1;

}

Chain of pointers/Pointer to Pointer:

A pointer can point to the address of another pointer. Consider the following example. int x=456, *p1, **p2; //[pointer-to-pointer];

p1 = &x;

p2 = &p1;

printf(“%d”, *p1); will display value of x 456.

printf(“%d”, *p2); will also display value of x 456. This is because p2 point p1, and p1 points x. Therefore p2 reads the value of x through pointer p1. Since one pointer is points towards another pointer it is called chain pointer. Chain pointer must be declared with ** as in **p2.

Manipulation of Pointers

We can manipulate a pointer with the indirection operator „*‟, which is known as

dereference operator. With this operator, we can indirectly access the data variable content.

Syntax:

*ptr_var;

Example:

#include<stdio.h>

void main()

{

int a=10, *ptr;

ptr=&a;

printf(”\n The value of a is ”,a);

*ptr=(*ptr)/2;

printf(”The value of a is.”,(*ptr));

}

Output:

The value of a is: 10

The value of a is: 5

4.4.2 Pointer Expression & Pointer Arithmetic

C allows pointer to perform the following arithmetic operations: A pointer can be incremented / decremented.

Any integer can be added to or subtracted from the pointer.

A pointer can be incremented / decremented.

In 16 bit machine, size of all types[data type] of pointer always 2 bytes. Eg: int a;

int *p;

p++;

Each time that a pointer p is incremented, the pointer p will points to the memory location of the next element of its base type. Each time that a pointer p is decremented, the pointer p will points to the memory location of the previous element of its base type.

int a,*p1, *p2, *p3;

p1=&a; p2=p1++; p3=++p1;

printf(“Address of p where it points to %u”, p1); 1000

printf(“After incrementing Address of p where it points to %u”, p1); 1002 printf(“After assigning and incrementing p %u”, p2); 1000

printf(“After incrementing and assigning p %u”, p3); 1002

In 32 bit machine, size of all types of pointer is always 4 bytes.

The pointer variable p refers to the base address of the variable a. We can increment the pointer variable,

p++ or ++p

This statement moves the pointer to the next memory address. let p be an integer pointer with a current value of 2,000 (that is, it contains the address 2,000). Assuming 32-bit integers, after the expression

p++;

the contents of p will be 2,004, not 2,001! Each time p is incremented, it will point to the next integer. The same is true of decrements. For example,

p--;

will cause p to have the value 1,996, assuming that it previously was 2,000. Here is why: Each time that a pointer is incremented, it will point to the memory location of the next element of its base type. Each time it is decremented, it will point to the location of the previous element of its base type.

Any integer can be added to or subtracted from the pointer.

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 >

#include<conio.h>

void 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);

}

/* Sum of two integers using pointers*/

#include <stdio.h>

int main()

{

int first, second, *p, *q, sum; printf("Enter two integers to add\n"); scanf("%d%d", &first, &second);

p = &first;

q = &second;

sum = *p + *q;

printf("Sum of entered numbers = %d\n",sum);

return 0;

}

4.4.3 Pointers and Arrays

Array name is a constant pointer that points to the base address of the array[i.e the first element of the array]. Elements of the array are stored in contiguous memory locations. They can be efficiently accessed by using pointers.

Pointer variable can be assigned to an array. The address of each element is increased by one factor depending upon the type of data type. The factor depends on the type of pointer variable defined. If it is integer the factor is increased by 2. Consider the following example:

int x[5]={11,22,33,44,55}, *p;

p = x; //p=&x; // p = &x[0];

Remember, earlier the pointer variable is assigned with address (&) operator. When working with array the pointer variable can be assigned as above or as shown below:

Therefore the address operator is required only when assigning the array with element. Assume the address on x[0] is 1000 then the address of other elements will be as follows

x[1] = 1002 x[2] = 1004 x[3] = 1006 x[4] = 1008

The address of each element increase by factor of 2. Since the size of the integer is 2 bytes the memory address is increased by 2 bytes, therefore if it is float it will be increase 4 bytes, and for double by 8 bytes. This uniform increase is called scale factor.

p = &x[0];

Now the value of pointer variable p is 1000 which is the address of array element x[0]. To find the address of the array element x[1] just write the following statement.

p = p + 1;

Now the value of the pointer variable p is 1002 not 1001 because since p is pointer variable the increment of will increase to the scale factor of the variable, since it is integer it increases by 2.

The p = p + 1; can be written using increment or decrement operator ++p; The values in the array element can be read using increment or decrement operator in the pointer variable using scale factor.

Consider the above example.

printf(“%d”, *(p+0)); will display value of array element x[0] which is 11. printf(“%d”, *(p+1)); will display value of array element x[1] which is 22. printf(“%d”, *(p+2)); will display value of array element x[2] which is 33. printf(“%d”, *(p+3)); will display value of array element x[3] which is 44. printf(“%d”, *(p+4)); will display value of array element x[4] which is 55.

/*Displaying the values and address of the elements in the array*/

#include<stdio.h>

void main()

{

int a[6]={10, 20, 30, 40, 50, 60};

int *p; int i; p=a;

for(i=0;i<6;i++)

{

printf(“%d”, *p); //value of elements of array printf(“%u”,p); //Address of array

}

getch();

}

/* Sum of elements in the Array*/

#include<stdio.h>

#include<conio.h>

void main()

{

int a[10];

int i,sum=0;

int *ptr;

printf("Enter 10 elements:n");

for(i=0;i<10;i++)

scanf("%d",&a[i]);

ptr = a; /* a=&a[0] */

for(i=0;i<10;i++)

{

sum = sum + *ptr; //*p=content pointed by 'ptr' ptr++;

}

printf("The sum of array elements is %d",sum);

}

/*Sort the elements of array using pointers*/

#include<stdio.h>

int main(){

int i,j, temp1,temp2;

int arr[8]={5,3,0,2,12,1,33,2};

int *ptr;

for(i=0;i<7;i++){

for(j=0;j<7-i;j++){

if(*(arr+j)>*(arr+j+1)){ ptr=arr+j; temp1=*ptr++; temp2=*ptr;

*ptr--=temp1;

*ptr=temp2;

}}}

for(i=0;i<8;i++){

printf(" %d",arr[i]); } }

4.4.4 Pointers and Multi-dimensional Arrays

The array name itself points to the base address of the array.

Example: int a[2][3]; int *p[2];

p=a; //p points to a[0][0]

/*Displaying the values in the 2-d array*/

#include<stdio.h>

void main()

{

int a[2][2]={{10, 20},{30, 40}};

int *p[2]; int i,j; p=a;

for(i=0;i<2;i++)

{

for(j=0;j<2;j++)

{

printf(“%d”, *(*(p+i)+j)); //value of elements of array

}

}

getch();

}

4.5 Dynamic Memory Allocation

The process of allocating memory during program execution is called dynamic memory allocation.

 
Dynamic memory allocation functions

S. No.

Function

Syntax

Use

1

malloc()

ptr=(cast-type*)malloc(byte-size)

Allocates requested size of bytes

and returns a pointer first byte of allocated space.

2

calloc()

ptr=(cast-type*)calloc(n,element-size);

Allocates space for an array elements, initializes to zero and then returns a pointer to memory.

3

free()

free(ptr);

dellocate the previously allocated

space.

4

realloc()

ptr=realloc(ptr,newsize);

Change the size of previously

allocated space.

1. Explain in detail about the function prototypes. [8]

2. Explain in detail about parameter passing methods. [8]

3. Describe the pass by value concept. [8]

4. Describe the pass by reference concept. [8]

5. Explain the concept of recursive functions in C. [8]

6. Write short notes on: pointer arithmetic. [6]

. Explain in detail about pointers and array in C. [8]