Stack vs. heap pointers in C

Question

I'm currently learning C and I'm confused about memory layout and pointers.

In the following code, it is my understanding that the array is allocated on the stack.

#include <stdio.h>

int main () {
   int x[4];
   x[0] = 3; x[1] = 2; x[2] = 1;
   printf("%p\n",x);
   printf("%p\n", &x);
}

My question is, why do the two print calls output the same value?

I tried a similar snippet using malloc (allocate on the heap), and the values differ.

#include <stdio.h>
#include <stdlib.h>

int main () {
   int *x = malloc(sizeof(int) * 4);
   x[0] = 3; x[1] = 2; x[2] = 1;
   printf("%p\n",x);
   printf("%p\n", &x);
}

Answer 1

The reason is that unlike you were probably taught, arrays are not pointers. Arrays in C decay into pointers¹ under some circumstances. When you pass an array to a function, it decays into a pointer to the first element. The address of that element is the same as the address of the entire array (an address is always to the first byte of an object).

What you get from malloc is not an array, but the address of a chunk of memory. You assign the address to a pointer. But the pointer and the chunk are separate entities. So printing the value of the pointer, as opposed to its address, yields different results.

---

(1) Decay is a fancy term for a type of implicit type conversion. When an array expression is used in most places (such as being passed as an argument to a function that expects a pointer), it automatically turns into a pointer to its first element. The "decay" is because you lose type information, i.e. the array size.

Answer 2

Your two print calls print the same value because one tries to print the array, which decays to a pointer to the array, and the other prints the address of the array. A pointer to the array contains the address of the array, so they're the same value.

In the second case, one prints the value of x, the other prints the address of x. Since x is a pointer to the block of memory you allocated, these must be different values.

So in the first case, all you have is an array (x). In the second case, you have an allocated block of memory (unnamed) and a pointer to that allocated block (x).

Answer 3

It is perhaps surprising that one can indeed take the address of a whole array, partly because one doesn't need to very often. The array in a sense is a single object, which has one address, which is the address of its first byte. Like with all objects, the address is obtained with the address operator, &.

The first element of an array (like all of its elements) has an address, too, which is the address of its first byte. A pointer to its first element is what the array type is "adjusted" to when it is passed as an argument to a function.

These two bytes are identical, and have the same address. But they have different types, which becomes obvious if you add 1 to them and print them again.

The pointer y, by contrast, is its own distinct object (probably 4 or 8 bytes in size; enough to store an address in it). Like any object it has an address which can be obtained with the & operator. Perhaps confusingly, it also contains an address, in this case the address of the first byte of the array. The two are of course not equal: The pointer object resides at a different location than the array (namely next to it on the stack, even if Olaf doesn't like that).

Minor remark: You use %p for printing pointers, which is good. If you do that, you should strictly spoken cast the pointer which you print to a void pointer: printf("%p\n", (void *)x);.