C++, End to End

Constexpr and Compile-Time Evaluation

Most computation in a C++ program happens when the program runs. Some of it can happen while the program is being *compiled* instead, which means it costs nothing at runtime and, for things like array sizes, can unlock language features that need a compile-time constant in the first place. This chapter is about the tools that make that possible.

constexpr variables

A constexpr variable's value must be computable at compile time, and the compiler enforces that: if you try to initialize one with something that isn't knowable until runtime, it's a compile error, not a runtime one.

c++ · live, editable, runnableOpen in Compiler Explorer ↗

#include <iostream> int main() { constexpr int max_players = 4; int scores[max_players]; // fine: max_players is a compile-time constant int runtime_value = 4; // int bad[runtime_value]; // not standard C++, this needs a compile-time constant std::cout << max_players << "\n"; }

This is stricter than plain const. A const int can be initialized from a runtime value (const int x = some_function(); compiles fine, x just can't be reassigned afterward). constexpr additionally demands the value be known at compile time.

constexpr functions

A function marked constexpr *can* run at compile time, if all of its arguments are compile-time constants and its body is simple enough (no undefined behavior, since the compiler has to actually evaluate it). Called with runtime values instead, the exact same function just runs normally at runtime. It's one function definition serving both cases.

c++ · live, editable, runnableOpen in Compiler Explorer ↗

#include <iostream> constexpr int factorial(int n) { return (n <= 1) ? 1 : n * factorial(n - 1); } int main() { constexpr int compile_time_result = factorial(5); // computed during compilation std::cout << compile_time_result << "\n"; int n; std::cin >> n; // hypothetically: a value only known at runtime // factorial(n) here would run as a normal recursive function call instead std::cout << factorial(10) << "\n"; }

"Can run at compile time" is not the same as "always runs at compile time". Whether a particular call actually gets evaluated at compile time depends on context (is the result being used somewhere that demands a compile-time constant, like an array bound or another constexpr variable's initializer) and, in some cases, is left up to the compiler to decide as an optimization.

consteval: forcing compile-time evaluation

C++20 added consteval, which is stricter still: a consteval function (an "immediate function") must always be evaluated at compile time. Calling it with anything that isn't a compile-time constant is a compile error, not a fallback to runtime execution.

c++ · live, editable, runnableOpen in Compiler Explorer ↗

// godbolt-run -std=c++20 consteval int square(int x) { return x * x; } int main() { constexpr int result = square(5); // fine, compile-time // int n; // std::cin >> n; // int bad = square(n); // compile error: n isn't known at compile time return result; }

Use consteval when a function genuinely only makes sense at compile time (generating a lookup table baked into the binary, validating a format string) and you want the compiler to guarantee that rather than silently falling back to a runtime call.

if constexpr: compile-time branching

Ordinary if picks a branch at runtime, but both branches still have to compile even if one is never taken for a given type. if constexpr (C++17) discards the untaken branch entirely at compile time, which matters most inside templates, where the discarded branch might not even be valid code for the type actually being used.

c++ · live, editable, runnableOpen in Compiler Explorer ↗

#include <iostream> #include <type_traits> template<typename T> void describe(T value) { if constexpr (std::is_integral_v<T>) { std::cout << value << " is an integer\n"; } else if constexpr (std::is_floating_point_v<T>) { std::cout << value << " is a floating-point number\n"; } else { std::cout << "some other type\n"; } } int main() { describe(42); describe(3.14); }

static_assert: compile-time checks

Covered in more depth in the error-handling chapter, but worth repeating here since it's the natural companion to everything above: static_assert(condition, "message") fails the *build* if condition isn't true, checked entirely at compile time. It's the standard way to validate assumptions about constexpr computations, type sizes, or template parameters before the program ever runs.

Try it yourself: make a runtime function compile-time capable›

This function works fine, but it can only ever run at runtime. Add constexpr to its signature, then declare a constexpr variable that calls it, forcing compile-time evaluation, and confirm it still works correctly when called with a genuinely runtime value too.

c++ · live, editable, runnableOpen in Compiler Explorer ↗

#include <iostream> int sum_up_to(int n) { int total = 0; for (int i = 1; i <= n; ++i) total += i; return total; } int main() { std::cout << sum_up_to(10) << "\n"; }