if consteval

if consteval { ... } else { ... } — специальный синтаксис внутри constexpr/consteval функции, позволяющий выбрать одну из двух веток кода в зависимости от того, вычисляется ли текущий вызов на этапе компиляции (compile-time context) или в рантайме. Ветка if consteval выполняется в compile-time контексте, ветка else — в рантайме.The if consteval { ... } else { ... } syntax inside a constexpr/consteval function lets you pick one of two code paths depending on whether the current call is being evaluated at compile time or at runtime. The if consteval branch runs in the compile-time context, the else branch runs at runtime.

constexpr double my_sqrt(double x) {
    if (std::is_constant_evaluated()) {
        return newton_sqrt(x);  // медленно, но валидно на этапе компиляции// slow, but valid at compile time
    } else {
        return fast_bit_hack_sqrt(x);  // быстрый рантайм-путь// fast runtime path
    }
}
// обычный if — компилятор в пограничных случаях может перепутать ветку// a plain if — the compiler can pick the wrong branch in edge cases

constexpr double my_sqrt(double x) {
    if consteval {
        return newton_sqrt(x);  // compile-time ветка// compile-time branch
    } else {
        return fast_bit_hack_sqrt(x);  // рантайм-ветка// runtime branch
    }
}
// нет условия в скобках — компилятор не может ошибиться с контекстом// no condition in parens — the compiler can't misjudge the context

std::is_constant_evaluated() из C++20 решала ту же задачу, но как обычная функция внутри обычного if — а обычный if живёт по правилам обычного кода, что создавало несколько источников проблем:C++20's std::is_constant_evaluated() solved the same problem, but as an ordinary function inside an ordinary if — and an ordinary if lives by the rules of ordinary code, which created several sources of trouble:

if consteval — это не выражение, а специальная форма if, встроенная в грамматику языка: компилятор точно знает в момент разбора кода, в какой ветке он находится, потому что сам факт "сейчас идёт constant evaluation" — это часть его собственного состояния интерпретатора, а не результат вызова функции времени выполнения. Ветка после if consteval компилируется и выполняется только при constant evaluation, ветка else — только в рантайме (либо является обязательной, либо её отсутствие означает "ничего не делать в рантайме").The if consteval construct isn't an expression but a special form of if baked into the language grammar: the compiler knows for certain, at the point of parsing, which branch it's in, because the very fact "constant evaluation is happening right now" is part of its own interpreter state, not the result of a runtime function call. The branch after if consteval compiles and runs only during constant evaluation, the else branch only at runtime (or its absence simply means "do nothing at runtime").

constexpr unsigned popcount(unsigned x) {
    if consteval {
        // compile-time: обычный цикл, компилятор развернёт и свернёт сам// compile-time: a plain loop, the compiler unrolls/folds it itself
        unsigned count = 0;
        while (x) { count += x & 1; x >>= 1; }
        return count;
    } else {
        // рантайм: аппаратный интринсик, недоступный на этапе компиляции// runtime: a hardware intrinsic, unavailable at compile time
        return __builtin_popcount(x);
    }
}

constexpr unsigned a = popcount(0b1011);  // compile-time ветка, a == 3 вычислено при компиляции// compile-time branch, a == 3 computed during compilation
unsigned b = popcount(runtime_value);      // рантайм-ветка, вызов __builtin_popcount в исполняемом коде// runtime branch, __builtin_popcount call in the emitted code

Важно, что if consteval не заменяет std::is_constant_evaluated() целиком — последняя по-прежнему существует и валидна там, где нужно проверить контекст в виде булева значения (например, передать его дальше как параметр), но новый синтаксис становится предпочтительным для собственно ветвления кода, потому что даёт компилятору однозначные гарантии для каждой ветки.Note that if consteval doesn't replace std::is_constant_evaluated() entirely — the latter still exists and is valid wherever you need the context as a plain boolean value (e.g. to pass it further as a parameter), but the new syntax becomes the preferred choice for actual code branching, because it gives the compiler unambiguous guarantees for each branch.

// синтаксические тонкости: нет скобок вокруг consteval, и отрицание не пишется через !// syntax subtleties: no parens around consteval, and negation isn't written with !
constexpr void log_if_runtime() {
    if !consteval {
        std::puts("running at runtime");  // отрицание: "if !consteval", а не "if (!is_constant_evaluated())"// negation: "if !consteval", not "if (!is_constant_evaluated())"
    }
}

• cppreference — if consteval
• WG21 P1938 — if consteval