Types of Constants

C++ offers two keywords for working with values that should not change: const and constexpr. Both are often described as ways to make something constant, which makes them easy to confuse. They answer different questions, though. const is about a promise that the program makes not to change a value. constexpr is about when a value can be computed, specifically whether it can be evaluated at compile time. Keeping these two questions separate is the key to using either keyword correctly.

The promise is the important part. A const declaration does not say anything about how the value was produced. It says only that, once the value exists, the program will not change it. Because the compiler enforces the promise, an attempt to modify a const value is rejected rather than silently allowed.

const is used primarily to specify interfaces. When data is passed to a function, a const qualifier lets the programmer say that the function will not modify it, so the data can be passed without fear of it being changed. The source example declares a function as double sum(const vector<double>&), noting that sum will not modify its argument. The const in that declaration is the promise, and it is part of the function's interface. A caller who reads the signature knows what the function promises not to do to its input.

The examples in this part use three kinds of values. One is a named constant declared with const, called dmv, with the value 17. Another is an ordinary variable that is not declared constant, called var. The third is a vector of doubles, called v, that is also not a constant. Each is used in a different initialization. For every line the question is the same: does the compiler have enough information to evaluate this initialization before the program runs, and is the promise about the value being kept?

Notice that max1 and max2 have the same shape. Both multiply 1.4 by a call to square applied to a single int. The only difference is the name passed in. Changing var to dmv changes the outcome, even though both lines have the same form. This is the first clue that constexpr is not about the shape of the expression but about what the compiler can know in advance.

A constant expression is an expression that can be evaluated at compile time. An expression whose value depends on something only known when the program runs can only be evaluated at run time. The distinction is not about whether an expression looks constant on the page. It is about whether every value the expression depends on is available to the compiler before execution begins.

The left column holds the only values the compiler can treat as fixed. The right column holds values whose content is not available until the program runs. A constant expression is built only from things in the left column. Any expression that touches the right column is a run-time expression.

The source gives two reasons for constexpr: it allows data to be placed in read-only memory, where it is unlikely to be corrupted, and it supports performance. A constexpr declaration therefore makes a stronger demand than const. A const value may be computed at run time. A constexpr variable must be initialized with a constant expression, so the compiler has to be able to compute its initializer before the program runs.

The pipeline above shows the stage the source describes. The initializer is not something the program works out while it runs. The compiler has to be able to evaluate it first, and because the value is fixed in advance, the data can be placed in read-only memory.

When you are unsure whether a constexpr initialization will compile, apply the rule from the source directly. Ask whether every value that the initializer depends on is one the compiler can evaluate at compile time. If every dependency is known in advance, the initializer is a constant expression and is accepted. If any dependency is an ordinary variable or a run-time value, the initialization is an error.

The two keywords share the word constant, but they differ on the questions that matter most when you write code. const answers the question of whether the program promises not to change the value. constexpr answers the question of whether the value can be computed at compile time. Because these are separate questions, a value can be const without being constexpr. This is why the line const double max3 = 1.4 * square(var); is allowed. The source comment says it may be evaluated at run time.