if statement

• 如果语法上可以解析为 结构化绑定 声明，则将其解释为结构化绑定声明。

• 属性说明符序列 (可选) 声明说明符序列 声明符 花括号或等号初始化器

结构化绑定声明

该声明具有以下限制：

• 其 初始化器 中的 表达式 不能是数组类型。
• 声明说明符序列 只能包含类型说明符和 constexpr 。

该声明的决策变量是由 声明引入的 虚构变量 e 。

带初始化器的 if 语句

若使用 init-statement ，则 if 语句等价于

或

除了由 init-statement 声明的名称（若 init-statement 是声明）和由 condition 声明的名称（若 condition 是声明）在同一作用域内，该作用域也是两个 statement s 的作用域。

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 语句 。constexpr if 语句的所有子语句都是 控制流受限语句 。

在 constexpr if 语句中， 条件 必须是 上下文转换到 bool 类型的常量表达式 (C++23 前) 上下文转换到 bool 的表达式，且该转换是 常量表达式 (C++23 起) 。

如果 条件 产生 true ，则 false 语句 被丢弃（如果存在），否则 true 语句 被丢弃。

被丢弃语句中的 return 语句不参与函数返回类型推导：

template<typename T>
auto get_value(T t)
{
    if constexpr (std::is_pointer_v<T>)
        return *t; // 对 T = int* 推导返回类型为 int
    else
        return t;  // 对 T = int 推导返回类型为 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> 实例化后保持值依赖，
            // 这会影响隐式 lambda 捕获
            // 该复合语句可能仅在 lambda 体实例化后被丢弃
        }
    };
}

被丢弃语句不能对所有可能的特化都非良构：

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 问题 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 起) 可用作 constexpr if 语句的 初始化语句 以缩小类型别名的作用域。

立即求值 if 语句

以 if consteval 开头的语句被称为 立即求值 if 语句 。立即求值 if 语句的所有子语句都是 控制流受限语句 。

语句 必须是复合语句，即使它不是复合语句（因此会导致编译错误），它仍将被视为立即求值 if 语句的一部分：

constexpr void f(bool b)
{
    if (true)
        if consteval {}
        else ; // 错误：不是复合语句
               // else 不与外层 if 关联
}

如果立即求值 if 语句在 明显常量求值上下文 中被求值，则执行 复合语句 。否则，如果存在 语句 ，则执行该语句。

如果语句以 if ! consteval 开头，则 复合语句 和 语句 （如果有）都必须为复合语句。此类语句不被视为立即求值 if 语句，但等价于立即求值 if 语句：

• if ! consteval { /* stmt */ } 等价于
  

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

• if ! consteval { /* stmt-1 */ } else { /* stmt-2 */ } 等价于
  

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

立即求值 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';
}