Advanced Pointers

You thought pointers were hard? Wrong. The rest is just applying the same one idea, "a variable holding an address", one more layer deep.

Pointers to pointers

A pointer can point at another pointer, useful whenever a function needs to modify which address the caller's pointer holds, not just the value at that address:

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

void allocate(int **outPtr) {
    *outPtr = malloc(sizeof(int)); // sets the CALLER's pointer
    **outPtr = 42;
}

int main(void) {
    int *p = NULL;
    allocate(&p);        // pass the address OF the pointer
    printf("%d\n", *p);  // 42
    free(p);
    return 0;
}

int **outPtr reads right-to-left: "outPtr is a pointer to (a pointer to an int)". *outPtr gives you the inner pointer, **outPtr dereferences all the way down to the int itself.

Pointers and arrays

An array name, used in most expressions, "decays" into a pointer to its first element, this is why array indexing and pointer arithmetic are interchangeable in C:

#include <stdio.h>

int main(void) {
    int scores[3] = {10, 20, 30};
    int *p = scores;       // decays to &scores[0]

    printf("%d\n", scores[1]); // 20
    printf("%d\n", *(p + 1));  // 20, identical operation
    p++;                        // now points at scores[1]
    return 0;
}

p + 1 doesn't add 1 byte, it adds 1 * sizeof(int) bytes, pointer arithmetic automatically scales by the size of whatever type the pointer points to.

Function pointers

A pointer can even point at executable code, letting you pass a function around like a value:

#include <stdio.h>

int square(int n) { return n * n; }

int apply(int (*fn)(int), int value) {
    return fn(value);
}

int main(void) {
    int result = apply(square, 5); // 25
    printf("%d\n", result);
    return 0;
}

int (*fn)(int) declares fn as "a pointer to a function taking an int and returning an int", this is the mechanism behind callbacks in C, and it's exactly how the object system you'll build next represents dynamic behavior.