if инструкция

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

• attribute-specifier-seq(необязательно) decl-specifier-seq declarator brace-or-equal-initializer

Объявление структурированной привязки

Объявление должно удовлетворять следующим ограничениям:

• expression в его инициализаторе не может иметь тип массива.
• Последовательность спецификаторов объявления может содержать только спецификаторы типа и 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

Инструкция, начинающаяся с ifconstexpr, называется инструкцией constexpr if. Все подчиненные инструкции constexpr if являются инструкциями с ограниченным потоком управления.

В инструкции constexpr if condition должно быть контекстно преобразуемым константным выражением типа 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; // deduces return type to int for T = int*
    else
        return t;  // deduces return type to int for T = int
}

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

extern int x; // no definition of x required

int f()
{
    if constexpr (true)
        return 0;
    else if (x)
        return x;
    else
        return -x;
}

Вне шаблона отброшенная инструкция полностью проверяется. ifconstexpr не заменяет директиву препроцессора #if:

void f()
{
    if constexpr(false)
    {
        int i = 0;
        int *p = i; // Error even though in discarded statement
    }
}

Если инструкция constexpr if находится внутри шаблонной сущности и после инстанцирования condition не является зависимым от значения, отброшенная инструкция не инстанцируется при инстанцировании охватывающего шаблона.

template<typename T, typename ... Rest>
void g(T&& p, Rest&& ...rs)
{
    // ... handle p
    if constexpr (sizeof...(rs) > 0)
        g(rs...); // never instantiated with an empty argument list
}

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

template<class T>
void g()
{
    auto lm = [=](auto p)
    {
        if constexpr (sizeof(T) == 1 && sizeof p == 1)
        {
            // this condition remains value-dependent after instantiation of g<T>,
            // which affects implicit lambda captures
            // this compound statement may be discarded only after
            // instantiation of the lambda body
        }
    };
}

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

template<typename T>
void f()
{
    if constexpr (std::is_arithmetic_v<T>)
        // ...
    else {
        using invalid_array = int[-1]; // ill-formed: invalid for every T
        static_assert(false, "Must be arithmetic"); // ill-formed before 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 {
        // workaround before CWG2518
        static_assert(dependent_false_v<T>, "Must be arithmetic");
    }
}

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

Consteval if

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

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

constexpr void f(bool b)
{
    if (true)
        if consteval {}
        else ; // error: not a compound-statement
               // else not associated with outer if
}

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

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

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

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

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

#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 // use a compile-time friendly algorithm
    {
        return ipow_ct(base, exp);
    }
    else // use runtime evaluation
    {
        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';
}