Compile-Time Evaluation with static_assert

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

The tool that makes this possible is a single keyword, constexpr, placed on the function declaration. Along with static_assert, which asks the compiler to check a condition during translation, it lets you have the compiler verify a value before the program ever runs. The rest of this article follows what the compiler does at each step, so you can see exactly where the keyword changes the outcome.

Read this 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. Before reading on, consider what that one keyword might change, because the answer is the central idea of this article.

A constexpr function 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 function's result may be used: a call to the function can take part in a constant expression, which is an expression the compiler itself will evaluate.

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 any declaration by naming the pieces in order.

Applying the pattern to square: constexpr marks eligibility, double is the return type, square is the name, double x is the parameter list, and the braces contain the body that returns x times x. The pattern is a template to check against, not a separate statement you write on its own.

The useful way to think about a constexpr function is as a two-part relationship. 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. The following code puts both parts together.

The rule is strict in one direction. For a function to be usable in a constant expression, it must be defined constexpr. Declaring a function constexpr is what makes it eligible. A plain function that happens to compute the same value does not qualify just because its body is simple.

The diagram shows only the declaration check described in the source. A function declared constexpr moves onto the path where its calls can be evaluated by the compiler. Without that declaration, the function does not qualify for constant expressions, however the call is written. The body and the call can look identical; the declaration is what decides.

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.

The two columns are not about how the arithmetic is written. An ordinary function with the same body still runs when the program runs, and a call to it cannot take part in a constant expression. A constexpr function with that body can be evaluated by the compiler, so its call may appear inside static_assert or in another constant expression.