if statement

• Если синтаксически это может быть разрешено как structured binding объявление, то оно интерпретируется как объявление структурированной привязки.

• attribute-specifier-seq (опционально) decl-specifier-seq declarator brace-or-equal-initializer

Декларация структурированной привязки

Декларация имеет следующие ограничения:

• Выражение в её инициализаторе не может быть типа массива.
• Последовательность спецификаторов объявления может содержать только спецификаторы типа и constexpr .

Переменной решения декларации является введённая переменная e введённая декларацией .

if инструкции с инициализатором

Если используется init-statement , инструкция if эквивалентна

или

За исключением того, что имена, объявленные в init-statement (если init-statement является объявлением) и имена, объявленные в condition (если condition является объявлением), находятся в одной области видимости, которая также является областью видимости обоих statement ов.

std::map<int, std::string> m;
std::mutex mx;
extern bool shared_flag; // guarded by mx
int demo()
{
    if (auto it = m.find(10); it != m.end())
        return it->second.size();
    if (char buf[10]; std::fgets(buf, 10, stdin))
        m[0] += buf;
    if (std::lock_guard lock(mx); shared_flag)
    {
        unsafe_ping();
        shared_flag = false;
    }
    if (int s; int count = ReadBytesWithSignal(&s))
    {
        publish(count);
        raise(s);
    }
    if (const auto keywords = {"if", "for", "while"};
        std::ranges::any_of(keywords, [&tok](const char* kw) { return tok == kw; }))
    {
        std::cerr << "Token must not be a keyword\n";
    }
}

Constexpr if

Утверждение, начинающееся с if constexpr , известно как constexpr if statement . Все подутверждения constexpr if statement являются control-flow-limited statements .

В операторе constexpr if условие должно быть контекстно преобразуемым константным выражением типа bool (до C++23) выражением, контекстно преобразуемым в bool , где преобразование является константным выражением (начиная с C++23) .

Если condition возвращает true , тогда statement-false отбрасывается (если присутствует), в противном случае statement-true отбрасывается.

Операторы return в отброшенном операторе не участвуют в определении типа возвращаемого значения функции:

template<typename T>
auto get_value(T t)
{
    if constexpr (std::is_pointer_v<T>)
        return *t; // выводит тип возвращаемого значения как int для T = int*
    else
        return t;  // выводит тип возвращаемого значения как int для T = int
}

Отброшенное выражение может ODR-использовать переменную, которая не определена:

extern int x; // определение x не требуется
int f()
{
    if constexpr (true)
        return 0;
    else if (x)
        return x;
    else
        return -x;
}

Вне шаблона, отброшенное выражение полностью проверяется. if constexpr не является заменой для #if директивы препроцессора:

void f()
{
    if constexpr(false)
    {
        int i = 0;
        int *p = i; // Ошибка, даже в отброшенном операторе
    }
}

Если constexpr if оператор появляется внутри шаблонной сущности , и если условие не является value-dependent после инстанцирования, отброшенный оператор не инстанцируется при инстанцировании охватывающего шаблона.

template<typename T, typename ... Rest>
void g(T&& p, Rest&& ...rs)
{
    // ... обработка p
    if constexpr (sizeof...(rs) > 0)
        g(rs...); // никогда не инстанцируется с пустым списком аргументов
}

Условие остается зависимым от значения после инстанцирования, если это вложенный шаблон:

template<class T>
void g()
{
    auto lm = [=](auto p)
    {
        if constexpr (sizeof(T) == 1 && sizeof p == 1)
        {
            // это условие остается зависимым от значений после инстанцирования g<T>,
            // что влияет на неявные захваты лямбды
            // этот составной оператор может быть отброшен только после
            // инстанцирования тела лямбды
        }
    };
}

Отброшенное утверждение не может быть некорректным для каждой возможной специализации:

template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        using invalid_array = int[-1]; // некорректно: недопустимо для любого T
        static_assert(false, "Must be arithmetic"); // некорректно до CWG2518
    }
}

Распространенным обходным решением до реализации CWG issue 2518 для таких перехватывающих все случаев операторов было использование зависящего от типа выражения, которое всегда false :

template<typename>
constexpr bool dependent_false_v = false;
template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        // обходное решение до CWG2518
        static_assert(dependent_false_v<T>, "Must be arithmetic");
    }
}

Объявление typedef или объявление псевдонима (начиная с C++23) может использоваться в качестве init-statement constexpr if для ограничения области видимости псевдонима типа.

Consteval if

Утверждение, начинающееся с if consteval , известно как consteval if утверждение . Все подутверждения consteval if утверждения являются ограниченными по потоку управления утверждениями .

statement должен быть составным оператором, и он все равно будет рассматриваться как часть константного оператора if, даже если он не является составным оператором (и, следовательно, приводит к ошибке компиляции):

constexpr void f(bool b)
{
    if (true)
        if consteval {}
        else ; // ошибка: не составной оператор
               // else не связан с внешним if
}

Если выражение consteval if вычисляется в контексте явного постоянного вычисления , compound-statement выполняется. В противном случае, statement выполняется, если он присутствует.

Если оператор начинается с if ! consteval , то составной-оператор и оператор (если присутствует) должны быть составными операторами. Такие операторы не считаются consteval if операторами, но эквивалентны им:

• if ! consteval { /* stmt */ } эквивалентно
  

if consteval { } else { /* stmt */ } .

if consteval { } else { /* stmt */ } .

• if ! consteval { /* stmt-1 */ } else { /* stmt-2 */ } эквивалентно
  

if consteval { /* stmt-2 */ } else { /* stmt-1 */ } .

составной-оператор в consteval if операторе (или оператор в отрицательной форме) находится в контексте непосредственной функции , где вызов непосредственной функции не обязан быть константным выражением.

#include <cmath>
#include <cstdint>
#include <cstring>
#include <iostream>
constexpr bool is_constant_evaluated() noexcept
{
    if consteval { return true; } else { return false; }
}
constexpr bool is_runtime_evaluated() noexcept
{
    if not consteval { return true; } else { return false; }
}
consteval std::uint64_t ipow_ct(std::uint64_t base, std::uint8_t exp)
{
    if (!base) return base;
    std::uint64_t res{1};
    while (exp)
    {
        if (exp & 1) res *= base;
        exp /= 2;
        base *= base;
    }
    return res;
}
constexpr std::uint64_t ipow(std::uint64_t base, std::uint8_t exp)
{
    if consteval // использовать алгоритм, дружественный к вычислению на этапе компиляции
    {
        return ipow_ct(base, exp);
    }
    else // использовать вычисление во время выполнения
    {
        return std::pow(base, exp);
    }
}
int main(int, const char* argv[])
{
    static_assert(ipow(0, 10) == 0 && ipow(2, 10) == 1024);
    std::cout << ipow(std::strlen(argv[0]), 3) << '\n';
}