Addresses and pointers

Memory as numbered boxes

Think of memory as a very long row of boxes, each holding one byte, and each with a number called its address. When you declare int x = 42;, the compiler reserves 4 consecutive boxes (on typical systems) and remembers where. The address of x is the number of its first byte.

int x = 42;

address    name   value
0x7ffc10   x      42        (4 bytes: 0x7ffc10 … 0x7ffc13)

The & operator: "address of"

int x = 42;
printf("value %d, address %p\n", x, (void *) &x);   /* address changes from run to run */

Pointer variables

A pointer is a variable whose value is an address. Its type says what kind of value lives at that address: int * is "pointer to int", char * is "pointer to char". The * in a declaration means "this is a pointer".

int x = 42;
int *p = &x;          /* p holds the address of x */

address    name   value
0x7ffc10   x      42
0x7ffc18   p      0x7ffc10   ← p "points to" x

x          → 42
&x         → 0x7ffc10
p          → 0x7ffc10   (the same address)
*p         → 42         (the value AT that address)
&p         → 0x7ffc18   (p itself also lives somewhere)

Dereferencing: * as an operator

In an expression, *p means "the thing p points to". Reading *p reads x; assigning to *p changes x. This is how one piece of code can change a variable that belongs to someone else.

int x = 42;
int *p = &x;
*p = 50;                 /* writes through the pointer */
printf("%d\n", x);       /* 50: x itself changed */
(*p)++;                  /* brackets needed: *p++ would move p instead (precedence!) */
printf("%d\n", x);       /* 51 */

Pointer sizes and types

printf("%zu %zu %zu\n", sizeof(int *), sizeof(char *), sizeof(double *));   /* 8 8 8 on 64-bit systems */

A pointer must point to the right type. int *p = &d; where d is a double is a compile warning and a bug: *p would read the first 4 bytes of the double as if they were an int. void * is a generic pointer that can hold any data address but cannot be dereferenced until converted to a real type.