consteval / constinit

consteval объявляет функцию, которая ДОЛЖНА быть вычислена на этапе компиляции при каждом вызове — если вызов не может быть constant expression, это ошибка компиляции. Это отличается от constexpr-функции, которая МОЖЕТ быть вычислена как во время компиляции, так и в рантайме — выбор зависит от контекста конкретного вызова. constinit — квалификатор переменной, гарантирующий её статическую инициализацию (constant initialization, на этапе компиляции, до старта main), но НЕ делающий переменную константой: значение можно менять после инициализации, гарантия касается только момента и способа инициализации.consteval declares a function that MUST be evaluated at compile time on every call — if a call can't be a constant expression, it's a compile error. This differs from a constexpr function, which MAY be evaluated either at compile time or at runtime — the choice depends on the context of the specific call. constinit is a variable qualifier guaranteeing static initialization (constant initialization, at compile time, before main starts), but it does NOT make the variable a constant: its value can be changed after initialization — the guarantee concerns only the moment and manner of initialization.

constexpr int square(int x) { return x * x; }

constexpr int a = square(5);   // вычислено на этапе компиляции// evaluated at compile time

int runtime_input();
int b = square(runtime_input());
// то же square() — но выполнится в рантайме,// the same square() — but runs at runtime,
// потому что аргумент неизвестен на этапе компиляции// because the argument isn't known at compile time

consteval int square(int x) { return x * x; }

constexpr int a = square(5);   // ок, compile-time// ok, compile-time

int runtime_input();
// int b = square(runtime_input()); // ошибка компиляции —// int b = square(runtime_input()); // compile error —
// аргумент не constant expression, а consteval требует это ВСЕГДА// the argument isn't a constant expression, and consteval always requires one

Для consteval-функции ("immediate function") компилятор обязан вычислить каждый вызов на этапе трансляции — если хотя бы один вызов невозможно свести к constant expression, вся трансляция завершается ошибкой в этой точке, а не деградирует к обычному вызову функции в рантайме. Для constinit-переменной компилятор обязан использовать constant initialization — тот же механизм, что и для constexpr-переменных на этапе инициализации, — но по завершении инициализации переменная остаётся обычным изменяемым объектом, без ограничения "неизменности" в оставшейся части программы.For a consteval function ("immediate function"), the compiler must evaluate every call at translation time — if even one call can't be reduced to a constant expression, the whole translation fails right there, instead of degrading to an ordinary runtime function call. For a constinit variable, the compiler must use constant initialization — the same mechanism constexpr variables use at their initialization step — but once initialization completes, the variable remains an ordinary mutable object, with no "immutability" restriction for the rest of the program.

// consteval — hash строкового литерала, гарантированно compile-time:// consteval — hashing a string literal, guaranteed compile-time:
consteval std::uint64_t hash_literal(const char* s, std::size_t n) {
    std::uint64_t h = 1469598103934665603ull;
    for (std::size_t i = 0; i < n; ++i) h = (h ^ s[i]) * 1099511628211ull;
    return h;
}
switch (hash_literal("GET", 3)) { /* ... *//* ... */ }

// constinit — гарантирует момент инициализации, не иммутабельность:// constinit — guarantees the moment of initialization, not immutability:
constinit int g_counter = 0;   // инициализирован статически, до main()// statically initialized, before main()

void tick() {
    g_counter = g_counter + 1;   // абсолютно валидно — g_counter не const// perfectly valid — g_counter isn't const
}

Отсылка к соседнему, но другому compile-time механизму: static_assert (см. ../cpp11/static-assert.html) проверяет условие на этапе компиляции и не порождает никакого кода при успехе — он не вычисляет значение, а просто утверждает факт. consteval/constinit, напротив, про то, ЧТО и КОГДА вычисляется, а не про проверку условия.A nod to a neighboring but different compile-time mechanism: static_assert (see ../cpp11/static-assert.html) checks a condition at compile time and produces no code on success — it doesn't compute a value, it just asserts a fact. consteval/constinit, by contrast, are about WHAT and WHEN gets computed, not about checking a condition.

Практический пример: диспетчеризация по строке через compile-time хеш HTTP-метода. Идея — превратить строковые литералы в целочисленные константы ещё на этапе компиляции для case-меток switch; сам хеш рантайм-строки, приходящей извне, вычисляется отдельной, обычной constexpr-функцией (той же реализацией, но без consteval), поскольку её аргумент в общем случае не constant expression:A practical example: string dispatch via a compile-time hash of an HTTP method. The idea is to turn string literals into integer constants at compile time for switch case labels; hashing the runtime string that arrives from the outside is done by a separate, ordinary constexpr function (the same implementation, just without consteval), since its argument generally isn't a constant expression:

consteval std::uint32_t fnv1a_ce(std::string_view s) {   // для case-меток — только литералы// for case labels — literals only
    std::uint32_t h = 2166136261u;
    for (char c : s) h = (h ^ static_cast<std::uint32_t>(c)) * 16777619u;
    return h;
}
constexpr std::uint32_t fnv1a(std::string_view s) {   // та же логика, для рантайм-аргумента switch(...)// same logic, for the runtime switch(...) argument
    std::uint32_t h = 2166136261u;
    for (char c : s) h = (h ^ static_cast<std::uint32_t>(c)) * 16777619u;
    return h;
}

void dispatch(std::string_view method) {
    switch (fnv1a(method)) {          // вычисляется в рантайме — constexpr это разрешает// evaluates at runtime — constexpr permits this
        case fnv1a_ce("GET"):  handle_get();  break;   // case-метка — литерал, обязана быть compile-time// case label — a literal, must be compile-time
        case fnv1a_ce("POST"): handle_post(); break;
        default:                  handle_unknown();
    }
}
// fnv1a_ce(method) с рантайм-method здесь был бы ошибкой компиляции —// fnv1a_ce(method) with a runtime method here would be a compile error —
// consteval именно это и не разрешает, в отличие от constexpr// that's exactly what consteval disallows, unlike constexpr

• cppreference — consteval specifier
• cppreference — constinit specifier
• WG21 P1073 — Immediate functions (consteval)