Question

#include<stdio.h>

int main()
{
  int *previous, *current ;
  int a[5] = {1,2,3,4,5};
  current =(int *) a ;
  previous = current ;
  current = *( (int**) current ) ; //my question is on this line

  printf ("\nprevious is 0x%x and current is 0x%x \n ", previous , current ) ;
  printf ("\nprev+1 0x%x ,  prev+4 0x%x \n", previous+1 , previous+4 ) ;
return 0;
}

and the output is :

bash-3.00$ ./a.out

previous is 0xffffd0f8 and current is 0x1

prev+1 0xffffd0fc ,  prev+4 0xffffd108

My question is: “current” was previously pointing to the start of the array, before it was referenced and dereferenced back again. How does the following statement change the value of “current”?

current = *( (int**) current ) ;

Also, if I print *previous it will print 1 while *current will core dump. What is the reason for this behaviour?

Answer 1

current = *( (int**) current ) ;

First, you cast current to an int**, so the value stored in the sizeof(int**) bytes starting at &current are to be interpreted as the address of an int*. Then you dereference the pointer obtained from the cast. That means, the int** assumed to be stored there is followed, and the sizeof(int*) bytes at that address are stored in current.

Now, current pointed to the first element of the array a, so the bytes stored at the beginning of a are copied into current. If sizeof(int*) == sizeof(int), the int value 1 stored in a[0] is then interpreted as an address. If sizeof(int*) == 2*sizeof(int) (the other common occurrence), then the pointer value is composed of the two ints 1 and 2.

previous points to the first element of a, so dereferencing previous yields the value 1. Dereferencing current now tries to read an int from address 1 (it is undefined behaviour, so whatever else would happen wouldn’t violate the standard, but that’s the normal course of things), which normally isn’t accessible for the process.