const and volatile

Based on A Little Book of C, Chapter 27 (pp. 89–92)

The const Qualifier

const is a promise to the compiler — and to other programmers — that a value won't change. The compiler enforces it: any code that tries to modify a const object gets a compile error.

const int max_users = 100;
max_users = 200;  // ❌ compile error

But const isn't just for simple variables. You can apply it to:

• Variables (like const int max_users)
• Function parameters — the most common use in real code
• Pointers — in three different positions, each locking something different
• Return types — promising the caller they get read-only data

const with Pointers

This is where most confusion happens. The position of const determines what is locked — the pointer itself or the data it points at.

int value = 42;
int other = 99;

// case 1: const int *p — data is read-only through p
const int *p = &value;
// *p = 100;          // ❌ data locked
p = &other;              // ✅ pointer can move

// case 2: int *const q — pointer is nailed in place
int *const q = &value;
*q = 100;                 // ✅ data is writable
// q = &other;          // ❌ pointer locked

For a deeper dive with quizzes and walkthroughs, see Lesson 3 — The const Matrix.

const in Function Parameters

This is where const earns its keep in everyday C. Marking a pointer parameter as const tells callers: "I will read your data, but I won't modify it."

void print_message(const char *msg) {
    printf("%s\n", msg);
}

The compiler now enforces this — any attempt to write through msg inside the function is a compile error. This is the standard convention for every C library function that takes a read-only string:

size_t strlen(const char *s);     // reads only
int    strcmp(const char *a, const char *b); // both read-only
char  *strcpy(char *dest, const char *src); // dest writable, src read-only

const with Return Types

You can also mark a return value as const — less common, but useful when you want to prevent the caller from modifying the returned data:

const char *get_error_message(void) {
    return "Something went wrong";
}

Now the caller gets a const char * — they can read the message but can't modify it.

Tiny Code: const Demo

Here's the book's example showing all the pieces together:

#include <stdio.h>

void show(const int *ptr) {
    // *ptr = 10;  // ❌ not allowed
    printf("Value: %d\n", *ptr);
}

int main(void) {
    int num = 5;
    const int *p = &num;
    int *const q = &num;

    printf("num = %d\n", num);
    // *p = 10;   // ❌ cannot modify through const pointer

    *q = 15;         // ✅ data modifiable through q
    printf("num after q change = %d\n", num);

    show(&num);      // ✅ function accepts const pointer
    return 0;
}

Output:

num = 5
num after q change = 15
Value: 15

The key thing to notice: p and q point to the same num, but p can't modify it while q can. The restriction is on the pointer variable, not on the memory itself.

The volatile Qualifier

volatile tells the compiler: this variable can change at any time, even if your code doesn't modify it. This prevents the compiler from optimising out reads and writes — every access must go to real memory.

Without volatile, the compiler assumes a variable only changes when your code explicitly changes it. This lets it do clever optimisations — caching values in registers, eliminating "unnecessary" reads, removing entire loops. But those optimisations break correctness when the value can change behind the compiler's back.

When to use volatile

• Hardware registers — memory-mapped I/O where a register's bits change due to external events.
• Variables modified by a signal handler or another thread — your code reads, but something else writes.
• Any value that must be re-read from memory each time — you need the actual current value, not a cached copy.

Example: polling a sensor

volatile int sensor_value;

while (sensor_value < 100) {
    // wait for sensor to reach threshold
}

Without volatile, the compiler might optimise this loop away entirely — it sees sensor_value never changes in the loop body, so it reads it once, compares to 100, and if it's below, loops forever (or eliminates the check entirely). With volatile, each iteration does a real memory read, so changes from external hardware are visible.

See it for yourself: with and without -O2

This is Exercise 2 from the book. Write two programs — one without volatile, one with — and compare the generated assembly:

Without volatile — at -O2, the compiler pre-computes the final value:

With volatile — the loop stays, with real memory round-trips:

Combining const and volatile

These two look like they contradict each other — const means "don't change it," volatile means "it might change at any time." But they target different actors:

They can coexist because they solve different problems. volatile says: "something outside this code (hardware, another thread) might change this value." const says: "your code must not change it."

const volatile int status_register = 0x1234;

This is routine in embedded systems — a hardware status register that your code can read to check a flag, but writing to it would trigger hardware behaviour (or be silently ignored).

Why It Matters

• const improves safety and clarity. It makes interfaces self-documenting and helps the compiler catch mistakes at build time instead of runtime.
• volatile preserves correctness in concurrent or hardware-driven systems where the compiler would otherwise optimise away essential reads and writes.
• Together they let you balance optimisation with precision — the critical insight needed for low-level C programming.

Misuse or forgetfulness:

• Skip const → risk accidental modification, lose compiler-enforced documentation, can't safely pass string literals.
• Skip volatile → risk the compiler removing critical reads/writes, causing bugs that only appear with optimisations enabled.

Try It Yourself — Exercises from the Book (p. 93)

These exercises are designed to be run as code — each one is a short program that demonstrates a specific behaviour. Try each one in order.

Exercise 1 — Modifying a const int through a pointer

// ex01_const_through_pointer.c
#include <stdio.h>

int main(void) {
    const int x = 10;
    int *p = &x;  // 🟡 compiler warning: discards const qualifier
    *p = 20;      // ❌ undefined behaviour — modifying a const object
    printf("%d\n", x);
    return 0;
}

Compile with gcc -Wall -Wextra. What warnings do you get?

Exercise 2 — volatile and assembly comparison

Write two programs:

// ex02a_no_volatile.c
#include <stdio.h>
int main(void) {
    int counter = 0;
    for (int i = 0; i < 10000000; i++)
        counter++;
    printf("%d\n", counter);
    return 0;
}

// ex02b_volatile.c
#include <stdio.h>
int main(void) {
    volatile int counter = 0;
    for (int i = 0; i < 10000000; i++)
        counter++;
    printf("%d\n", counter);
    return 0;
}

Compile each with gcc -O2 -S and inspect the assembly:

gcc -O2 -S ex02a_no_volatile.c -o ex02a.s
gcc -O2 -S ex02b_volatile.c -o ex02b.s

The non-volatile version will likely have its entire loop eliminated — the compiler pre-computes the final value and passes it directly to printf. The volatile version retains the full loop with real memory round-trips per iteration.

Exercise 3 — const char *msg function parameter

#include <stdio.h>

void greet(const char *msg) {
    msg[0] = 'X';   // ❌ try to modify
    printf("%s\n", msg);
}

int main(void) {
    greet("hello");
    return 0;
}

Compile. The compiler should produce an error like "assignment of read-only location" or "discards qualifiers". Remove the offending line and compile again.

Exercise 4 — const int *p vs int *const p

#include <stdio.h>

int main(void) {
    int value = 42;
    int other = 99;

    // const int *p — data is locked
    const int *p = &value;
    // *p = 100;         // uncomment — compile error?
    p = &other;            // allowed — pointer can move

    // int *const q — pointer is locked
    int *const q = &value;
    *q = 100;              // allowed — data is writable
    // q = &other;        // uncomment — compile error?

    // const int *const r — both locked
    const int *const r = &value;
    // *r = 200;          // uncomment — compile error?
    // r = &other;        // uncomment — compile error?

    return 0;
}

Uncomment each line one at a time. Which compile? Which don't?

Exercise 5 — const volatile int flag

#include <stdio.h>

const volatile int flag = 0x1234;

int main(void) {
    for (int i = 0; i < 5; i++)
        printf("flag = %d\n", flag);

    // flag = 99;   // uncomment — compile error?

    return 0;
}

Two facts in one program: volatile forces a memory read each loop iteration (though the value doesn't change here, the compiler can't cache it). const prevents you from writing to flag.

Check yourself

What you can now do