Questions on C pointers

Question

In the below code, I made an integer array and tried printing it with the function DisplayIntArray in order to try to understand how pointers work.

Some questions are embedded in the comments.

/*==========================================================
 * pointer tests
 *========================================================*/

#include <stdio.h>

void DisplayIntArray(char *Name, int *Data, int lenArray) {
  /* Display integer array data */
  int m;
  printf("%s = \n", Name);
  for(m = 0; m < lenArray; m++, printf("\n")){
    printf("%d ", *(Data+m));
    printf("%d ", Data[m]);
    // how come these two print statements display the same thing?
  }
}

void DisplayDoubleArray(char *Name, double *Data, int lenArray) {
  /* Display double array data */
  int m;
  printf("%s = \n", Name);
  for(m = 0; m < lenArray; m++, printf("\n")){
    printf("%f ", *(Data+m));
    printf("%f ", Data[m]);
  }
}


int main ()
{

  int int_array[5] = {1, 2, 3, 4, 5};
  int *int_array_p = &int_array[0];

  // print array with function DisplayIntArray
  // this works fine
  DisplayIntArray("int array", int_array_p, 5);
  printf("\n");


  // Curiously the function still works when passing the actual
  // array instead of the pointer.
  DisplayIntArray("int array", int_array, 5);
  printf("\n");


  // print array using the wrong function
  // This print should fail because I'm passing an integer value pointer
  // into a double. But shouldn't it print the first element
  // correctly? - Why not?
  DisplayDoubleArray("int array", int_array_p, 5);
  printf("\n");


  return 0;
}

The output of the code is:

int array = 
1 1 
2 2 
3 3 
4 4 
5 5 

int array = 
1 1 
2 2 
3 3 
4 4 
5 5 

int array = 
0.000000 0.000000 
0.000000 0.000000 
0.000000 0.000000 
-0.000000 -0.000000 
0.000000 0.000000

Answer 1

In C, if you have a pointer p that points to an array and integral value i, then, p[i] is the same as *(p+i). They both evaluate to the i-th element of the array.

Given that, it makes sense that

printf("%d ", *(Data+m));
printf("%d ", Data[m]);

print the same thing.

You said:

// Curiously the function still works when passing the actual
// array instead of the pointer.

When an array variable is used in an expression such as the call to DisplayIntArray, the variable evaluates to the pointer to the first element. Hence,

   DisplayIntArray("int array", int_array_p, 5);
   DisplayIntArray("int array", int_array, 5);

are equivalent.

You said:

// This print should fail because I'm passing an integer value pointer
// into a double. But shouldn't it print the first element
// correctly? - Why not?
DisplayDoubleArray("int array", int_array_p, 5);

Here, the argument type and variable being used in the argument don't match. Using gcc, I get the following warning:

soc.c: In function ‘main’:
soc.c:51:35: warning: passing argument 2 of ‘DisplayDoubleArray’ from incompatible pointer type
   DisplayDoubleArray("int array", int_array_p, 5);
                                   ^
soc.c:18:6: note: expected ‘double *’ but argument is of type ‘int *’
 void DisplayDoubleArray(char *Name, double *Data, int lenArray) {

With that call, the program should exhibit undefined behavior.

Answer 2

printf("%d ", *(Data+m));
printf("%d ", Data[m]);
// how come these two print statements display the same thing?

Because they mean the same thing; Data[m] and m[Data] would both be equivalent to *(Data+m) here, they all refer to the same element.

// Curiously the function still works when passing the actual
// array instead of the pointer.

When you try to use an array in an expression like this one, it automatically "decays" into a pointer to the array, this means that you can not pass an array itself, only a pointer to it.

// print array using the wrong function
// This print should fail because I'm passing an integer value pointer
// into a double. But shouldn't it print the first element
// correctly? - Why not?

This is undefined behavior, in theory anything could happen. In practice, your compiler will most likely try to interpret the raw bit pattern of your int array as if it was a double array, and that happens to correspond to floating point values very close to 0.0.
It most likely won't print even the first element correctly, because an int and a double are stored differently in memory.

Answer 3

printf("%d ", *(Data+m));
printf("%d ", Data[m]);

how come these two print statements display the same thing?

They display the same thing because for a pointer p to an array of at least m + 1 elements, the expressions *(p + m) and p[m] mean exactly the same thing. They are 100% synonymous. You can take that as part of a definition of pointer arithmetic, if you like.

---

int int_array[5] = {1, 2, 3, 4, 5};
int *int_array_p = &int_array[0];

this works fine:

DisplayIntArray("int array", int_array_p, 5);

Curiously the function still works when passing the actual array:

DisplayIntArray("int array", int_array, 5);

Yes, because in most contexts, an array name is automatically converted to a pointer to the first element of the array. This dovetails with your previous question, by the way.

---

Shouldn't [this] print the first element correctly? - Why [does it] not?

DisplayDoubleArray("int array", int_array_p, 5);

In DisplayDoubleArray() you pretend that the pointer argument points to the bytes of the representation of a double, but it doesn't. Dereferencing the pointer therefore produces undefined behavior.

Supposing that the actual behavior observed is to produce a value of type double -- which is reasonably likely but does not need to be the case, as the behavior is undefined -- you then tell printf() that it is receiving a value of type float, instead. For that reason, the behavior of printf() is also undefined. Possibly printf() interprets the first sizeof(float) bytes of the representation of the (undefined) double value as if they were the representation of a float value, but again, undefined. In any case, the representations of double and float are certainly different from the representation of int, and they are normally different from each other, as well. There is no reason whatever to think that any element of the array should be printed correctly this way.

Furthermore, the representation of type double is probably larger than that of type int in your system (8-byte doubles and 4-byte ints are common). If so, then executing DisplayDoubleArray() will attempt to access past the end of your underlying array unless some of the other aforementioned undefined behavior prevents it from doing so. Accessing past the end of the array also produces undefined behavior.

Answer 4

Most is due to the fact that an array name is implicitly converted to a pointer to the first element of the array.

See the comments below each cited block for additional details.

printf("%d ", *(Data+m));
printf("%d ", Data[m]);
// how come these two print statements display the same thing?

That is pointer arithmetic. Du to the conversion of array names, indexing into an array is identical to adding the index to a pointer to the first element of an array (which can be the name of the array itself).

// Curiously the function still works when passing the actual
// array instead of the pointer.
DisplayIntArray("int array", int_array, 5);

See above.

// print array using the wrong function
// This print should fail because I'm passing an integer value pointer
// into a double. But shouldn't it print the first element   
// correctly? - Why not?  
DisplayDoubleArray("int array", int_array_p, 5);

It should generate a compiler warning about implicit pointer conversion. If not, enable warnings, if still nothing appears, trash your compiler or kick the vendor. Converting one pointer to another is only guaranteed to convert it back without loss of information. Any access to the converted pointer is undefined behaviour. That means anything can happen. Your computer might grow teeth and bite you. Speculating what might happen is worthless, just don't do it!

Just FYI: the binary representation of int and float/double differs significantly to no surprise.

Answer 5

int *int_array_p = &int_array[0];

Is only useful if you want to manipulate memory addresses independent of the array scope. Otherwise you must know that arrays decay to a pointer to the first element of the array.

Therefore &int_array[0]; is same as just int_array. They both return the array's offset address. You don't have to use the reference operator & as it returns "address of" and pointers are already an "address of"

---

double is guaranteed to be max 8 bytes while int is guaranteed to be max 4 bytes (on x64 bit architectures excluding some rare cases). Giving reference to an integer data type to a pointer to double is undefined behavior and modern compilers will give you a warning. However if you request the value to be printed as %i or %d it might return the correct result for you, otherwise it reads larger memory areas and depending on your endianness it will give you a variety of unintended results.