Pointers in C Explained

Pointers are what make C powerful – and what scare most learners. The idea is simple: every variable lives at a memory address, and a pointer is a variable that stores an address. Through a pointer, a function can change the caller's variables, walk through arrays, and manage memory directly. Master this lesson and the rest of C opens up.

Addresses

Memory is a long row of numbered bytes. When you declare int marks = 85;, the compiler reserves 4 bytes at some address – say 2000 – and stores 85 there. &marks ("address of marks") gives that address.

Declaring and using a pointer

#include <stdio.h>

int main(void) {
    int marks = 85;
    int *p = &marks;              // p is a "pointer to int" holding marks's address

    printf("marks       = %d\n", marks);
    printf("*p          = %d\n", *p);           // dereference: the value p points to
    printf("p == &marks ? %s\n", p == &marks ? "yes" : "no");

    *p = 92;                      // writing through the pointer changes marks
    printf("marks now   = %d\n", marks);

    int bonus = 5;
    p = &bonus;                   // a pointer can be re-pointed
    *p += 10;
    printf("bonus now   = %d, marks still %d\n", bonus, marks);
    printf("a pointer takes %zu bytes here\n", sizeof p);
    return 0;
}

marks       = 85
*p          = 85
p == &marks ? yes
marks now   = 92
bonus now   = 15, marks still 92
a pointer takes 8 bytes here

The * means two different things: in a declaration (int *p) it says "p is a pointer"; in an expression (*p) it means "follow the pointer". To print an address, use printf("%p", (void *)p) – the value changes every time the program runs.

NULL and wild pointers

#include <stdio.h>

int find_index(const int a[], int n, int key) {
    for (int i = 0; i < n; i++) if (a[i] == key) return i;
    return -1;
}

int main(void) {
    int *p = NULL;                         // "points nowhere" – safe to test
    if (p == NULL) printf("p is not pointing at anything yet\n");

    int data[] = {4, 8, 15};
    int value = 8;
    int i = find_index(data, 3, value);
    p = (i >= 0) ? &data[i] : NULL;
    if (p != NULL) printf("found %d at index %d\n", *p, i);
    return 0;
}

p is not pointing at anything yet
found 8 at index 1

Call by reference

In chapter 5, swap_wrong couldn't change the caller's variables because it received copies. Pass addresses instead, and the function can reach the originals:

#include <stdio.h>

void swap(int *a, int *b) {
    int t = *a;      // value at address a
    *a = *b;
    *b = t;
}

void min_max(const int arr[], int n, int *min, int *max) {   // "return" two values
    *min = *max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] < *min) *min = arr[i];
        if (arr[i] > *max) *max = arr[i];
    }
}

int main(void) {
    int x = 10, y = 20;
    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y);

    int marks[] = {67, 92, 45, 78};
    int lo, hi;
    min_max(marks, 4, &lo, &hi);
    printf("min = %d, max = %d\n", lo, hi);
    return 0;
}

x = 20, y = 10
min = 45, max = 92

This is exactly how scanf("%d", &n) stores a value into n, and how functions return several results.

Practice

Summary