Pointers

What is a pointer?

Every variable lives at some address in memory. A pointer holds that address instead of holding the data itself.

int x = 25;
int *p = &x;      /* p stores the address of x */

printf("%d\n", x);     /* 25 — the value */
printf("%p\n", (void *)p); /* address of x */
printf("%d\n", *p);    /* 25 — value AT that address */

Why pointers?

• Modify caller data — simulate call by reference in functions
• Return multiple results — write through several pointer parameters
• Efficiency — pass an address instead of copying a large struct or array
• Array traversal — walk data with p++ instead of indices
• Dynamic memory — malloc / free only work through pointers
• Data structures — linked lists, trees, and graphs are built from pointers
• Function pointers — choose behavior at runtime (callbacks, menus)

Types of pointers

Pointers with 1D arrays

An array name decays to the address of its first element, so a pointer can traverse it.

int a[5] = {10, 20, 30, 40, 50};
int *p = a;          /* same as &a[0] */

printf("%d\n", *p);       /* 10 */
printf("%d\n", *(p + 2)); /* 30 — same as a[2] */
printf("%d\n", p[3]);     /* 40 — pointers can be subscripted */

Four equivalent ways to reach element i:

Traversal with a moving pointer:

int *p;
for (p = a; p < a + 5; p++)
    printf("%d ", *p);

Pointers with 2D arrays

C stores 2D arrays in row-major order. For int m[2][3], m decays to int (*)[3] — a pointer to a row of 3 ints.

int m[2][3] = { {1, 2, 3}, {4, 5, 6} };
int (*p)[3] = m;      /* p points to row 0 */

printf("%d\n", p[1][2]);        /* 6 */
printf("%d\n", *(*(p + 1) + 2)); /* 6 — same thing */

Pointers with functions

(a) Passing pointers to functions — call by reference:

void swap(int *x, int *y) {
    int t = *x;
    *x = *y;
    *y = t;
}

swap(&a, &b);   /* a and b really change */

(b) Passing arrays (which decay to pointers):

int sum(int *a, int n) {   /* same as int a[] */
    int i, s = 0;
    for (i = 0; i < n; i++)
        s += a[i];
    return s;
}

(c) Returning a pointer:

int *findMax(int *a, int n) {
    int i;
    int *best = a;
    for (i = 1; i < n; i++)
        if (a[i] > *best)
            best = &a[i];
    return best;      /* safe: points into the caller's array */
}

(d) Function pointers — a pointer to code:

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int (*fp)(int, int);   /* pointer to such a function */

fp = add;
printf("%d\n", fp(7, 3));  /* 10 */

fp = sub;
printf("%d\n", fp(7, 3));  /* 4 */

Pointers with strings

A string is a char array ending in '\0', so a char * walks it naturally.

char s[] = "Hello";   /* writable array copy */
char *p = s;

while (*p != '\0') {
    putchar(*p);
    p++;
}

Length without strlen:

char *q = s;
while (*q) q++;
printf("length = %ld\n", (long)(q - s));  /* pointer subtraction */

Pointer arithmetic operations

Pointer arithmetic is scaled by the size of the pointed-to type. For int *p with 4-byte ints, p + 1 moves 4 bytes, not 1.

int a[5] = {10, 20, 30, 40, 50};
int *p = a;        /* points to a[0] */
int *q = &a[4];   /* points to a[4] */

p++;                    /* now a[1] — advanced by sizeof(int) */
printf("%d\n", *p);    /* 20 */
printf("%d\n", *(p + 2)); /* 40 */
printf("%ld\n", (long)(q - p)); /* 3 elements apart */

Reading complex declarations

Start at the identifier, go right when you can, left when you must.

Pointer to pointer — double indirection

int x = 5;
int *p = &x;
int **pp = &p;

printf("%d %d %d\n", x, *p, **pp);  /* 5 5 5 */

You need int ** when a function must change the caller’s pointer, not just the value it points to:

void point_to_first(int **pp, int *arr) {
    *pp = arr;      /* caller's pointer now points at arr */
}

const with pointers — where it goes matters

Passing 2D arrays to functions

/* All three headers are equivalent — columns must be known */
void f1(int m[2][3], int rows);
void f2(int m[][3], int rows);
void f3(int (*m)[3], int rows);

void f3(int (*m)[3], int rows) {
    int i, j;
    for (i = 0; i < rows; i++) {
        for (j = 0; j < 3; j++)
            printf("%d ", m[i][j]);
        printf("\n");
    }
}

• The column count must be known so the compiler can compute row offsets
• void f(int **m) is wrong for a real 2D array
• int ** is right only for an array of separately allocated row pointers

void pointers and generic code

int x = 42;
void *v = &x;

/* printf("%d", *v);   ERROR — cannot dereference void * */
printf("%d\n", *(int *)v);   /* cast first, then dereference */

• Holds the address of any object type
• Cannot be dereferenced or subscripted without a cast
• malloc returns void *, which is why it works with any type
• Used for generic APIs like qsort and memcpy

Wild, dangling, and null pointers

Function pointers in practice

/* A table of operations — no long if/else chain */
int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

int (*ops[3])(int, int) = { add, sub, mul };

printf("%d\n", ops[2](6, 7));  /* 42 */

• The function name alone is its address — no & needed
• fp(a, b) and (*fp)(a, b) are both valid calls
• Used for callbacks, menu dispatch, and comparison functions in qsort

Common mistakes