const and volatile: Promises You Make to the Compiler

Kenji writes software for a machine that stops when a button is pressed. His program waits by reading a flag that the button's circuit writes into memory. It worked for a year, he turned the optimiser on, and the machine stopped stopping.

Nothing about the flag changed. What changed is that the compiler noticed nobody in the program ever writes to it, so it read it once and reused the answer forever. This lesson is about the two words you use to tell the compiler things it cannot work out by reading your code.

const is a promise, and the compiler holds you to it

A qualifier is an extra word beside a type. It does not change the size or the values the variable can hold. It changes what the compiler will let you do with it, and what it is allowed to assume.

const says one thing: nothing in this program assigns to this variable after it is born. Break that promise and the build stops.

const int limit = 60;        the usual order
int const limit = 60;        the same thing, legal, rare in practice
const double PI = 3.14159;   any type takes it

volatile int sensor;         the other qualifier this lesson covers
const volatile int clock;    both at once, and this really happens

#include <stdio.h>

int main(void)
{
    const int SEATS_PER_ROW = 8;
    const int ROWS = 12;
    int booked = 71;

    printf("capacity : %d\n", SEATS_PER_ROW * ROWS);
    printf("booked   : %d\n", booked);
    printf("free     : %d\n", SEATS_PER_ROW * ROWS - booked);
    return 0;
}

capacity : 96
booked   : 71
free     : 25

Add one line, SEATS_PER_ROW = 10;, anywhere below the declaration. The Playground's GCC 12 answers error: assignment of read-only variable 'SEATS_PER_ROW' and no program is produced.

That is the entire mechanism. There is no run time check and no cost: the refusal happens while you are still typing, and the finished program contains nothing extra.

What const does not do

Three things people expect from const that it does not give you, and knowing them early saves an afternoon each.

It does not make a compile time constant. A const int is a variable you promised not to change. It is not a constant expression, so it cannot size a fixed array, and using it that way gives you a variable length array instead. Module 9 covers what that means.

It does not protect the value from everything. A pointer can be pointed at a const variable with the const cast away, and writing through that pointer compiles. What happens then is undefined behaviour, and the brain teaser at the foot of this lesson shows it happening.

It does not make anything safe across threads. A value that is never written is safe to read from anywhere, but that is a property of never writing it, not of the word const.

const and a pointer: two positions, two meanings

Module 11 teaches pointers properly. One thing belongs here. It is the single most misread line in C, and you will meet it in a library header long before Module 11.

A pointer declaration has two things that could be constant: the thing pointed at, and the pointer itself. Where you put the word decides which.

The reading trick is to say the declaration backwards from the name. int *const p reads as: p is a const pointer to int.

Both mistakes have their own message. Writing through the first kind gives error: assignment of read-only location '*p', and repointing the second kind gives error: assignment of read-only variable 'q'. Module 11 lesson 5 comes back to this with the memory drawn.

volatile: the variable that changes behind your back

Every optimisation a compiler performs rests on one assumption: it can see everything that touches your variables. For most programs that is true.

It is false in three places, and they are all real. A memory address wired to a piece of hardware. A variable a signal handler writes. A variable another thread writes.

volatile says this variable can change without any code of yours changing it. So read it from memory every single time, and never cache or delete a read.

You cannot see that from inside the program, because the value is the same either way. You can see it in the machine code the compiler produces.

The compiler reads a plain variable as few times as it likes

Two functions, identical except for one word. Each reads its variable twice and adds the two readings.

#include <stdio.h>

volatile int sensor = 21;
int counter = 21;

int twice_volatile(void)
{
    int first = sensor;
    int second = sensor;
    return first + second;
}

int twice_plain(void)
{
    int first = counter;
    int second = counter;
    return first + second;
}

int main(void)
{
    printf("twice_volatile : %d\n", twice_volatile());
    printf("twice_plain    : %d\n", twice_plain());
    return 0;
}

twice_volatile : 42
twice_plain    : 42

Both answers are 42, and they always will be. The difference is invisible from inside the program, so look at the machine code instead.

Compiled with the Playground's optimisation level, gcc -O2 -S, the two functions come out like this. The lines that matter are the ones reading memory.

twice_volatile:
        movl    sensor(%rip), %eax
        movl    sensor(%rip), %edx
        addl    %edx, %eax
        ret
twice_plain:
        movl    counter(%rip), %eax
        addl    %eax, %eax
        ret

Read the two blocks side by side. The volatile one loads from memory twice, exactly as the source asked. The plain one loads once and doubles what it got.

That second version is correct for an ordinary variable, and it is Kenji's bug. Both readings had to happen, and the compiler had no way to know that.

Compile the same file at -O0 and both functions load twice, which is why Kenji's program worked until the day he turned the optimiser on.

So volatile does not change the value, the type or the size. It removes one permission the compiler otherwise has.

Storage classes are a different word entirely

Beside a type you may also see static, extern, auto or register. Those are storage classes, not qualifiers, and they answer a different question.

A qualifier answers "what may be done to this value". A storage class answers "where does this variable live, and for how long".

They can appear together, and static const int limit = 60; is an ordinary thing to write. Module 7 gives the right hand column its own lesson.

#include <stdio.h>

int main(void)
{
    const int MINUTES_PER_HOUR = 60;
    int hours = 7;

    printf("%d hours is %d minutes\n", hours, hours * MINUTES_PER_HOUR);
    return 0;
}

7 hours is 420 minutes

#include <stdio.h>

const int MAX_UPLOAD_MB = 25;
const int SESSION_MINUTES = 15;
const int RETRY_LIMIT = 3;
const double VAT_RATE = 0.15;

int main(void)
{
    printf("upload limit    : %d MB\n", MAX_UPLOAD_MB);
    printf("session length  : %d minutes\n", SESSION_MINUTES);
    printf("retries allowed : %d\n", RETRY_LIMIT);
    printf("VAT rate        : %.2f\n", VAT_RATE);
    printf("session seconds : %d\n", SESSION_MINUTES * 60);
    return 0;
}

upload limit    : 25 MB
session length  : 15 minutes
retries allowed : 3
VAT rate        : 0.15
session seconds : 900

#include <stdio.h>

/* Something outside this program can write to stop_requested: a button,
   a signal handler, another thread. Nothing in this file writes to it. */
volatile int stop_requested = 0;

int main(void)
{
    int first_look = stop_requested;
    int second_look = stop_requested;

    printf("first look  : %d\n", first_look);
    printf("second look : %d\n", second_look);
    printf("both agree  : %d\n", first_look == second_look);
    return 0;
}

first look  : 0
second look : 0
both agree  : 1

const double VAT_RATE = 0.15;
VAT_RATE = 0.20;

const int limit;
limit = 60;

int a = 1;
int b = 2;
int *const q = &a;
q = &b;

volatile int counter = 0;
counter = counter + 1;

#include <stdio.h>

int main(void)
{
    const int limit = 60;
    int *escape = (int *)&limit;

    *escape = 30;

    printf("limit reads as %d\n", limit);
    return 0;
}

#include <stdio.h>

int main(void)
{
    const int SEATS_PER_ROW = 8;
    const int ROWS_PER_BLOCK = 12;

    int blocks = 0;
    int booked = 0;
    scanf("%d %d", &blocks, &booked);

    /* Three printf calls. Every number in them comes from a name. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int students = 45;

    printf("exam minutes : %d\n", 90);
    printf("pass mark    : %d\n", 40 * 60 / 100);
    printf("papers       : %d\n", students * 3);
    printf("bundles      : %d\n", students * 3 / 25);
    return 0;
}

exam minutes : 90
pass mark    : 24
papers       : 135
bundles      : 5

Next comes the other half of this module. It starts with the one function you have used in every program so far and never actually read.