Pointer basics

Prepared by
Mohammed Sikander
Technical Lead
Cranes Software International Limited

int main( )
{
int x = 10;
printf(“x = %d “ , x); //Prints the value of x.
printf(“&x = %p “ , &x);
}
mohammed.sikander@cranessoftware.com 2
& operator gets the address of variable.
%p is the correct format specifier to print address.

1. int main( )
2. {
3. int x = 10;
4. printf(“x = %d n“ , x); //Prints the value of x.
5. printf(“&x = %p n“ , &x);
6. int *ptr; //Declaration of pointer
7. ptr = &x;
8. printf(“ptr = %p n” , ptr);
9. printf(“*ptr = %d n” , *ptr);
10. }
6. * is used to declare a pointer
9. * is used to get value at address (dereference)

1. int main( )
2. {
3. int x = 5, y = 8;
4. int *p1 , p2;
5. p1 = &x;
6. p2 = &y;
7. printf(“ *p1 = %d “ , *p1);
8. printf(“ *p2 = %d “ , *p2);
9. }

Pointer size is same irrespective of type.
Pointers are like shorcuts to files (in windows).
A size of shortcut to a 1MB file, 1GB file ,
200MB file is same

int main( )
{
int x;
printf(“ x = %d “ , x); //garbage value.
int *ptr;
printf(“ ptr = %p “ , ptr); //garbage address.
printf(“ *ptr = %d “ ,*ptr);
}

int main( )
{
int *ptr1; // unitialized pointer
int *ptr2 = NULL; // NULL pointer
if(ptr2 != NULL) // Can be safeguarded
printf(“ *ptr2 = %d n”, *ptr2);
if(ptr1 != NULL) // Cannot be safeguarded
printf(“ *ptr1 = %d n”, *ptr1);
}

void update(int x)
{
x = x + 5;
printf(“Update x = %d “ , x);
}
int main( )
{
int x = 2;
update( x );
printf(“Main x = %d “ , x);
}

void update(int *px)
{
*px = *px + 5;
printf(“Update *px = %d “ , *px);
}
int main( )
{
int x = 2;
update( &x );
printf(“Main x = %d “ , x);
}

a = 3 , b = 7
a = a + b; //10
b = a – b; //3
a = a – b; //7
a = 7 , b = 10
a = a * b; //70
b = a / b; //7
a = a / b; //10
a = 5 , b = 10
a = a ^ b; //
b = a ^ b; //5
a = a ^ b; //10

int main( )
{
int arr[ ] = {12,23,34,54};
printf(“ %p “ , &arr[0]);
printf(“ %p “ , arr);
}
Array name gives the base address (address of first
element of array )

int main( )
{
int arr[ ] = {12,23,34,54};
int *p1 = &arr[0];
int *p2 = arr;
printf(“ %d “ , *p1);
printf(“ %d “ , *p2);
}

The following arithmetic operations with pointers are legal:
• add an integer to a pointer (+ and +=)
• subtract an integer from a pointer(- and -=).
• use a pointer as an operand to the ++ and -- operators.
• subtract one pointer from another pointer, if they point
to objects of the same type.
• compare two pointers
• Operations meaningless unless performed on an array
• All other arithmetic operations with pointers are illegal.

 Ptr = ptr + int
 When you add or subtract an integer to or from a
pointer, the compiler automatically scales the
integer to the pointer's type. In this way, the integer
always represents the number of objects to jump,
not the number of bytes.
 int x; // Assume address of x is 1000
 int *ptr = &x; // ptr = 1000
 ptr = ptr +1; // ptr-> 1004 and not 1001

int main( )
{
int arr[ ] = {0x21343782 , 0x54562319};
int *p1 = &arr[0];
printf(“ &arr[0] = %p n” , &arr[0]); //100
printf(“ &arr[1] = %p n” , &arr[1]); //104
printf(“ p1 = %p *p1 = %x” , p1 , *p1); //100
p1++;
printf(“ p1 = %p *p1 = %x” , p1 , *p1); //104
}

int main( )
{
short int arr[ ] = {0x2134 , 0x5456};
short int *p1 = &arr[0];
printf(“ &arr[0] = %p n” , &arr[0]); //100
printf(“ &arr[1] = %p n” , &arr[1]); //102
printf(“ p1 = %p *p1 = %x” , p1 , *p1); //100
p1++;
printf(“ p1 = %p *p1 = %x” , p1 , *p1); //102
}

int main( )
{
int arr[ ] = {0x21343782 , 0x54562319};
short int *p1 = &arr[0];
printf(“ *p1 = %x n” ,*p1);
p1++;
printf(“ *p1 = %x n” ,*p1);
}

int main( )
{
int arr[ 5 ] = {12,23,34,45,56};
int *ptr = arr;
for(int i = 0 ; i < 5 ; i++)
{
printf(“ %d “ , *ptr);
ptr++;
}
}

int main( )
{
int arr[ 5 ] = {12,23,34,45,56};
int *ptr = arr;
for(int i = 0 ; i < 5 ; i++)
{
printf(“ %d “ , ptr[ i ]);
}
}

int main( )
{
int arr[ 5 ] = {12,23,34,45,56};
for(int i = 0 ; i < 5 ; i++)
{
printf(“ %d “ , *(arr + i));
}
}

void printArray(int arr[])
{
printf(" %d " , sizeof(arr));
}
int main( )
{
int arr[5] = {12,23,34,54,67};
printf(" %d " , sizeof(arr));
printArray( arr );
}

void printArray(int arr[])
{
arr++; //No Error
}
int main( )
{
int arr[5] = {12,23,34,54,67};
// arr++; //Error
printArray( arr );
}

int main( )
{
const int x= 5;
x = 20; //ERROR
x++; //ERROR
}
int main( )
{
1. const int x= 5;
2. int *ptr = &x;
3. *ptr = 20;
4. printf(“ %d “ , x);
}

int main( )
{
1. const int x= 5;
2. const int *ptr = &x;
3. *ptr = 20;
4. printf(“ %d “ , x);
}

 Constant Pointer : Pointer is fixed to one
location.
 Pointer to const : Pointer has read-only
access.
 int * const cp;
 const int * pc;
 Constant pointer should be initialized.

int main( )
{
int x = 10 ;
const int y = 20;
const int * pc1 ;
pc1 = &x;
pc1 = &y;
}
int main( )
{
int x = 10 ;
const int y = 20;
int * const cp1;
int * const cp2 = &x;
int * const cp3 = &y;
const int * const cp4 = &y;
cp2 = &y;
}

 size_t strlen(const char *str);
size_t mystrlen(const char *str)
{
const char *end = str;
while( *end != ‘0’)
end++;
return end – str;
}

char * strcpy(char *dest, const char *src);
void mystrcpy(char *dest, const char *src)
{
while(1)
{
*dest = *src;
if(*dest == ‘0’)
return;
src++;
dest++;
}
}

char * strcpy(char *dest, const char *src);
void mystrcpy(char *dest, const char *src)
{
while((*dest++ = *src++))
{
}
}

int strcmp(const char *str1 , const char *str2);
int mystrcmp(const char *str1 , const char *str2)
{
while(1)
{
if(*str1 != *str2)
return *str1 - *str2;
if(*str1 == ‘0’)
return 0;
str1++;
str2++;
}
}
while(*str1 == *str2 && *str1 != ‘0’)
{
str1++;
str2++;
}
return *str1 - *str2;

Pointer basics

More Related Content

What's hot (20)

Similar to Pointer basics (20)

More from Mohammed Sikander (20)

Recently uploaded (20)

Pointer basics

Editor's Notes