Arithmetic operation with pointer in c programming

Rule 1: Addition arithmetic with pointers

Address + Number= Address

Address - Number= Address

Address++ = Address

Address-- = Address

++Address = Address

--Address = Address

If we will add or subtract a number from an address result will also be an address.

New address will be:

(1)What will be output of following c program?


#include<stdio.h>

int main(){

int *ptr=( int *)1000;

ptr=ptr+1;

printf(" %u",ptr);


return 0;

}

Output: 1002

(2)What will be output of following c program?


#include<stdio.h>

int main(){

double *p=(double *)1000;

p=p+3;

printf(" %u",p);


return 0;

}

Output: 1024

(3)What will be output of following c program?


#include<stdio.h>

int main(){

float array[5]={1.1f,2.2f,3.3f};

float(*ptr)[5];

ptr=&array;

printf("%u",ptr);

ptr=ptr+1;

printf(" %u",ptr);


return 0;

}

Output: 1000 1020

(4)What will be output of following c program?


#include<stdio.h>

typedef struct abc{

int far*a;

double b;

unsigned char c;

}ABC;

int main(){

ABC *ptr=(ABC *)1000;

ptr=ptr+2;

printf(" %u",ptr);


return 0;

}

Output: 1026

(5)What will be output of following c program?


#include<stdio.h>

typedef union abc{

char near*a;

long double d;

unsigned int i;

}ABC;

int main(){

ABC *ptr=(ABC *)1000;

ptr=ptr-4;

printf(" %u",ptr);


return 0;

}

Output: 960

(6)What will be output of following c program?


#include<stdio.h>

float * display(int,int);

int max=5;

int main(){

float *(*ptr)(int,int);

ptr=display;

(*ptr)(2,2);

printf("%u",ptr);

ptr=ptr+1;

printf(" %u",ptr);


return 0;

}

float * display(int x,int y){

float f;

f=x+y+max;

return &f;

}

Output: Compiler error

Rule 2: Difference arithmetic with pointers

Address - Address=Number

If you will subtract two pointers result will be a number but number will not simple mathematical subtraction of two addresses but it follow following rule:

If two pointers are of same type then:

Consider following example:


#include<stdio.h>

int main(){

int *p=(int *)1000;

int *temp;

temp=p;

p=p+2;

printf("%u %u\n",temp,p);

printf("difference= %d",p-temp);


return 0;

}

Output: 1000 1004

Difference= 2

Explanation:

Here two pointer p and temp are of same type and both are pointing toint data type varaible.

p-temp = (1004-1000)/sizeof(int)

=4/2

=2

(1)What will be output of following c program?


#include<stdio.h>

int main(){

float *p=(float *)1000;

float *q=(float *)2000;

printf("Difference= %d",q-p);


return 0;

}

Output: Difference= 250

Explanation:

q-p=(2000-100)/sizeof(float)

=1000/4

=250

(2)What will be output of following c program?


#include<stdio.h>

struct abc{

signed char c;

short int i;

long double l;

};

int main(){

struct abc *p,*q;

p=(struct abc *)1000;

q=(struct abc *)2000;

printf("Difference= %d",q-p);


return 0;

}

Output: Difference= 76

Explanation:

q-p=(2000-1000)/sizeof(struct abc)

=1000/(1+2+10)

=1000/13

=76

(3)What will be output of following c program?


#include<stdio.h>

typedef union xxx{

char far * c;

const volatile i;

long int l;

}XXX;

int main(){

XXX *p,*q;

p=(XXX *)1000;

q=(XXX *)2000;

printf("Difference= %d",q-p);


return 0;

}

Output: Difference= 250

Explanation:

q-p=(2000-100)/max(4,2,4)

=1000/4

=250

(4)What will be output of following c program?


#include<stdio.h>

int main(){

const volatile array[4]={0};

const volatile(*p)[4]=&array;

const volatile(*q)[4]=&array;

q++;

q++;

printf("%u %u\n",p,q);

printf("Difference= %d",q-p);


return 0;

}

Output: 1000 1016 (assume)

Difference= 2

Explanation:

q-p=(1016-1000)/sizeof(const volatile)

= 16/ (2*4)

=2

Rule 3: Illegal arithmetic with pointers

Address + Address=Illegal

Address * Address=Illegal

Address / Address=Illegal

Address % Address=Illegal

What will be output of following c program?


#include<stdio.h>

int main(){

int i=5;

int *p=&i;

int *q=(int *)2;

printf("%d",p+q);


return 0;

}

Output: Compiler error

Rule 4: We can use relation operator and condition operator between two pointers.

a. If two pointers are near pointer it will compare only its offset address.

What will be output of following c program?


#include<stdio.h>

int main(){

int near*p=(int near*)0x0A0005555;

int near*q=(int near*)0x0A2115555;

if(p==q)

printf("Equql");

else

printf("Not equal");

    return 0;
}

Output: Equal

b. If two pointers are far pointer it will compare both offset and segment address.

What will be output of following c program?


#include<stdio.h>

int main(){

int far*p=(int far*)0x0A0005555;

int far*q=(int far*)0x0A2115555;

if(p==q)

printf("Equql");

else

printf("Not equal");

    return 0;
}

Output: Not equal

c. If two pointers are huge pointer it will first normalize into the 20 bit actual physical address and compare to its physical address.

What will be output of following c program?


#include<stdio.h>

int main(){

int huge*p=(int huge*)0x0A0005555;

int huge*q=(int huge*)0x0A2113445;

if(p==q)

printf("Equql");

else

printf("Not equal");

    return 0;
}

Output: Equal

Rule 5: Bit wise arithmetic with pointers


We can perform bit wise operation between two pointers like

Address & Address=Illegal

Address | Address=Illegal

Address ^ Address=Illegal

~Address=Illegal

What will be output of following c program?


#include<stdio.h>

int main(){

int i=5,j=10;

int *p=&i;

int *q=&j;

printf("%d",p|q);


return 0;

}

Output: Compiler error

Rule 6: We can find size of a pointer using sizeof operator.

What will be output of following c program?


#include<stdio.h>

int main(){

int near*far*huge* p;

printf("%d",sizeof(p));

printf(" %d",sizeof(*p));

printf(" %d",sizeof(**p));


return 0;

}

Output: 4 4 2