Understanding Constants in C++

Most functions you have written so far run only when the program is running. The compiler translates your source code, and the body of the function is executed later, when the program starts doing work. This section introduces a different kind of function, one that the compiler itself can evaluate while it is still translating your program. The keyword that makes this possible is constexpr.

A program passes through two stages that matter here. The compiler translates the source code you wrote. Later, the translated program runs. For an ordinary function, the work of its body belongs to the second stage: the compiler records what the function does, and the body executes when the program reaches the call while running.

A constexpr function changes this picture. It is a function that can be evaluated by the compiler at compile time. The keyword is a request that the function be eligible for that kind of evaluation. Its practical effect is on where the result may be used: a call to the function can take part in a constant expression, which is an expression the compiler itself evaluates.

The diagram shows the path for a constexpr call inside a constant expression. The step that separates it from an ordinary call is the compile-time evaluation step, which happens before the program runs. The word constant is meant literally here: the value is fixed while the program is still being translated.

The relationship has two parts. The constexpr keyword sits on the function declaration and says the function is eligible. The constant expression is the place where that eligibility is used. Neither part alone describes the whole idea. A declaration with the keyword without any constant expression that uses it does nothing visible, and a constant expression that calls a function without the keyword has no permission to use it.

A constexpr function follows a general pattern. The keyword comes first, then the return type, the function name, the parameter list, and finally the body in braces. Each piece has a job, and you can check a declaration by naming each piece in order. The pattern is a template to check against, not a separate statement you write on its own.

Read the declaration as a complete definition. It creates a function named square that takes one double and returns a double. The only new word is constexpr, placed before the return type. Notice that the keyword is the first word of the declaration, not something placed after the parameter list or inside the body.

Now follow one call through the whole process. The declaration above defines square. Next, a static_assert line uses square inside a constant expression. A static_assert checks a condition when the program is compiled. The compiler must evaluate square(3.0) to decide whether the condition holds, which is only possible because square is declared constexpr.

Placing the two kinds of function side by side makes the difference easier to see. Both are ordinary-looking functions with a body that returns a value. What changes is whether a call to the function may appear in an expression that the compiler must evaluate.

When a compile-time check fails, the error location tells you where the expression was evaluated, which is the first clue to a wrong result. Suppose you expected square(3.0) to equal 10.0 and wrote the check accordingly. The arithmetic inside square is correct, so the failure is not inside its body. It is at the static_assert line, because that line is where the compiler compares the computed value with your expectation.