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

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Pointer basics

Similar to Pointer basics (20)

More from Mohammed Sikander

More from Mohammed Sikander (20)

Recently uploaded

Recently uploaded (20)

Pointer basics

Editor's Notes