What constexpr, consteval, and constinit each control

constexpr: usable in a constant context

A C++11 constexpr variable requires suitable constant initialization and makes the object const. A constexpr function provides the ability to enter constant evaluation, but an ordinary call need not be evaluated during translation. Putting the result into a constexpr variable or a static_assert is what establishes the constant-expression requirement for that call.

From C++14 onward, function-body rules gradually relaxed so loops and local variables could be used in constant computation, but you still must check limits against the target standard. constexpr is not an annotation meaning “always faster”; compilers can already optimize ordinary expressions. It first provides a language-level, checkable contract, not a performance-measurement conclusion.

consteval: the call must satisfy immediate-evaluation rules

C++20 consteval declares an immediate function. An ordinary potentially-evaluated call must satisfy constant-expression requirements; you cannot pass input that is known only at run time. It fits compile-time checks, fixed table generation, and other interfaces that truly must not fall back to run time—not a default decoration for every small function.

In the example, square supports both constant and run-time contexts, while fixed_limit is explicitly an immediate function. Neither automatically gets the right result just because it lexically appears outside main; the deciding factors are the function declaration, the arguments, and the call context. When you expose a tool, first decide whether you truly need to forbid run-time calls.

constinit: controls initialization, not later modification

C++20 constinit applies to variables with static or thread storage duration and requires that there be no dynamic initialization. It can turn an accidentally introduced run-time initialization into a compile error and helps control initialization dependencies across translation units, but it does not make later reads and writes automatically thread-safe, and it does not make the variable const.

The example initializes a global counter as a constant, then increments it in main, proving that constinit and read-only are different things. If you want a constant value that cannot be modified, constexpr is more appropriate. If you need mutable global state and only want to lock down the initialization phase, consider constinit, but first evaluate whether you can reduce shared global state.

Pitfalls

• A constexpr function can still run normally with run-time arguments; do not treat constexpr on the function as evidence that every call completed a compile-time computation.
• constinit is not const; it does not constrain later writes and does not provide synchronization. Multithreaded modification still needs an appropriate lock or atomic object.

Minimum C++20 · complete program · Download .cpp

#include <cassert>
#include <iostream>

constexpr int square(int x) { return x * x; }
consteval int fixed_limit() { return square(4); }
constinit int counter = square(2);

int main() {
    constexpr int limit = fixed_limit();
    static_assert(limit == 16);
    int input = 3;
    const int result = square(input);
    ++counter;
    assert(result == 9 && counter == 5);
    std::cout << limit << ' ' << result << ' ' << counter << '\n';
}

Compile locally

g++ -std=c++20 -Wall -Wextra -Wpedantic -pthread modern-constexpr.cpp -o example && ./example

Expected result

16 9 5

CHECK YOUR UNDERSTANDING

Close the answer. Explain it.

Why can constinit int local = 4 not be used directly as an ordinary automatic variable in main, while static constinit int local = 4 can?

Check the sources

• cppreference：constexpr specifier
• cppreference：consteval specifier
• C++ 标准草案 [dcl.constinit]

Drafts and official chapters change. The version mark is only the example’s minimum.