Оператор if

Операторы if с инициализатором

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

или

За исключением того, что имена, объявленные оператором инициализации (если оператор инициализации является объявлением), и имена, объявленные условием (если условие является объявлением), находятся в одной и той же области видимости, которая также является областью видимости обоих операторов.

std::map<int, std::string> m;
std::mutex mx;
extern bool shared_flag; // под охраной 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 << "Токен не должен быть ключевым словом\n";
    }
}

Constexpr if

Оператор, начинающийся с if constexpr известен как оператор constexpr if.

В операторе constexpr if значением условия должно быть контекстно преобразованное константное выражение типа bool (до C++23)выражение, контекстуально преобразованное в bool, где преобразование представляет собой константное выражение (начиная с C++23). Если значение равно 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 появляется внутри шаблонной сущности, и если условие не зависит от значения после создания экземпляра, отброшенный оператор не создаётся при создании экземпляра включающего шаблона.

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
    {
        // некорректо: недействителен для каждого T
        static_assert(false, "Должен быть арифметическим");
        using invalid_array = int[-1]; // некорректо: недействителен для каждого T
        static_assert(false, "Должен быть арифметическим"); // некорректо до CWG2518
    }
}

Обычный обходной путь перед реализацией CWG2518 для такого оператора catch-для-всех это выражение, зависящее от типа, которое всегда false:

template<typename>
inline 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>, "Должен быть арифметическим"); // ok
    }
}

Метки (goto цели, метки case и default:), появляющиеся в подоператоре constexpr, если на них можно сослаться (с помощью switch или goto) только в том же подоператоре.

Примечание: объявление typedef или объявление псевдонима (начиная с C++23) можно использовать в качестве оператора инициализации оператора constexpr if, чтобы уменьшить область видимости псевдонима типа.

Consteval if

Оператор, начинающийся с if consteval , известен как оператор consteval if. В операторе consteval if,

и составной-оператор и оператор (если есть) должны быть составными операторами.

Если оператор не является составным оператором, он всё равно будет рассматриваться как часть оператора consteval if (и, таким образом, приведёт к ошибке компиляции):

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

Если оператор consteval if оценивается в явно оцениваемом константном контексте, выполняется составной-оператор. Иначе, оператор выполняется, если он присутствует.

Метка case или default , появляющаяся в операторе consteval if, должна быть связана с оператором switch в том же операторе if. На метку, объявленную в подоператоре оператора consteval if, должна ссылаться инструкция только в том же подоператоре.

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

• if !consteval {/*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';
}

switch и goto не могут переходить в ветку утверждения constexpr if или утверждения consteval if (начиная с C++23).