Stack vs. heap pointers in C

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);
}

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.