C++ constexpr 函数在编译期执行的条件限制与副作用消除

核心约束：编译期求值的门槛

constexpr 函数的核心价值在于将计算从运行时迁移到编译期。但编译器并非对所有 constexpr 调用都进行编译期求值——它遵循严格的规则。

理解这些规则：编译期求值只有满足以下所有条件时才会发生。若违反任意一条，函数调用将退化到运行时执行。

条件一：所有参数必须为常量表达式

编译器在编译期能处理的函数参数，其值必须在编译期就完全确定。这意味着：

1. 参数类型：必须是字面量类型（literal type）。常见字面量类型包括：

   • 基本算术类型（int、double、char 等）
   • 枚举类型
   • 指针类型（需为 nullptr 或指向静态存储期的对象）
   • 引用类型（绑定到常量表达式）
   • 满足特定条件的类类型（见下文）

2. 参数值来源：只能来自：

   • 字面量（如 42、true）
   • constexpr 变量的值
   • 其他 constexpr 函数调用（需保证整个链在编译期可解）
   • 枚举成员
   • static constexpr 成员

无法通过编译期参数传递的情况：

• 运行时变量（如 int x = std::cin >> x; 后的 x）
• 非 constexpr 的 const 变量（即使值不变，编译器不保证进行编译期推导）
• 文件的 I/O、时间、随机数等运行时依赖值

示例对比：

constexpr int square(int x) { return x * x; }

constexpr int compile_time = square(5);       // ✅ 编译期: 25
int runtime_val = 5;
int runtime = square(runtime_val);            // ❌ 运行时: 实参不是常量表达式

关键动作：检查 函数调用的每个实参是否都是 constexpr 可求值的。有任意一个实参是运行时变量，整个调用即退化为运行时执行。

条件二：函数体必须严格符合 constexpr 函数体语法

从 C++14 起，constexpr 函数体允许更多语句，但仍有严格限制。以下规则适用于 C++17（当前主流标准）：

允许的语句

• 空语句 (;)
• static_assert
• typedef 和 using 别名
• using 指令
• if 语句（含 if constexpr）
• switch 语句
• for 循环（范围 for 也可）
• while 循环
• do 循环
• 返回语句
• 复合语句（{} 内的代码块）
• 表达式语句（如赋值，函数调用——但被调函数也必须为 constexpr）

禁止的语句

• goto 跳转
• try 块和异常处理（throw 表达式可以出现在非求值的上下文中，如 sizeof，但不能实际抛出）
• 非 constexpr 的变量定义（必须用 constexpr 声明或自动推导为编译期值）
• asm 定义
• 声明 static 或 thread_local 存储期的变量

特殊限制：constexpr 函数内不能出现 未定义行为。例如，有符号整数溢出、访问越界、空指针解引用等，在编译期求值时会导致编译错误（而非运行时未定义行为）。

constexpr int safe_inc(int x) {
    // return x + 1;  // 如果 x == INT_MAX，编译期求值会报错
    if (x < INT_MAX) return x + 1;
    else return INT_MAX;
}

条件三：函数返回类型必须为字面量类型

不仅参数类型需要字面量，函数的返回值类型也必须满足：

• 如果是 void，则函数只能由 constexpr 调用但在编译期不产生值（C++17 起 constexpr 函数可以返回 void）
• 如果是类类型，该类必须：
  • 拥有平凡的析构函数（或默认且未删除）
  • 构造函数至少有一个 constexpr 构造函数（通常定义 constexpr 默认构造函数）
  • 所有非静态数据成员都是字面量类型

常见反例：std::string 不是字面量类型（因为其析构函数非平凡），因此 constexpr 函数不能返回 std::string。但 C++20 起 std::string 的某些操作支持 constexpr（但依然不能用于编译期字符串拼接后返回）。

条件四：函数内部不得产生副作用（编译期求值时的限制）

副作用指任何修改程序状态或执行 I/O 的操作。在编译期求值中，以下行为被视为副作用，严格禁止：

禁止的副作用类型

C++20 的放宽：constexpr 中的 new/delete

C++20 引入了“透明分配”机制：constexpr 函数内可以动态分配内存，但必须确保在同一个编译期求值表达式中释放，且分配器必须满足 constexpr 要求。这为编译期创建和操作容器提供了可能（如 std::vector 在 C++20 中开始支持 constexpr）。但依然 禁止 将分配的内存地址逃逸到运行时（如赋值给非 constexpr 指针）。

副作用消除：如何让原本有副作用的代码在编译期安全执行

目标：将原本需要运行时变量或 I/O 的逻辑，改写成纯函数形式，使其满足 constexpr 条件。

方法一：将外部输入作为模板参数

若函数需要从外部获取常量，可使用模板参数强制编译期求值。

template<int N>
constexpr int factorial() {
    static_assert(N >= 0, "N must be non-negative");
    int result = 1;
    for (int i = 2; i <= N; ++i) result *= i;
    return result;
}

constexpr auto val = factorial<10>(); // 编译期计算 3628800

关键动作：替换 运行时输入为模板参数，使编译器在实例化时即获得常量表达式。

方法二：用 if constexpr 替代运行时分支

if constexpr 是编译期条件，它会丢弃未选中的分支，从而允许在未选中分支中使用非 constexpr 语句（只要不涉及求值）。

template<bool UseLogger>
constexpr int compute(int x) {
    if constexpr (UseLogger) {
        // 这个分支在编译期被丢弃，不会导致编译错误
        // 即使里面有 std::cout（但不能使用，因为 constexpr 函数体不允许）
        return x + 1; // 必须仍然是合法 constexpr 表达式
    } else {
        return x * 2;
    }
}

注意：if constexpr 内部的所有语句仍需符合 constexpr 函数体要求，但可以包含非 constexpr 的函数调用——只要这些调用不被实际求值（例如在 sizeof 或 typeid 中）。

方法三：将“副作用”转化为纯函数返回值

若函数需要统计操作次数或状态，可将状态作为参数传入并返回新状态，而非修改全局变量。

// ❌ 原版有副作用：修改静态变量
int counter = 0;
constexpr int bad_count() {
    ++counter;
    return counter;
}
// 编译错误：修改全局变量

// ✅ 纯函数版本：接受当前计数，返回新计数
constexpr std::pair<int, int> count_next(int current) {
    return {current + 1, current}; // 返回新值和旧值
}
constexpr auto [new_val, old_val] = count_next(5);

方法四：模拟循环与递归（取代可变状态）

许多运行时算法依赖循环内部的状态变更。在 constexpr 中，可用递归或折叠表达式模拟。

// 运行时版本：使用循环和累计变量
int sum_runtime(const std::vector<int>& v) {
    int s = 0;
    for (int x : v) s += x;
    return s;
}

// constexpr 版本：使用递归 + 数组（或 initializer_list）
template<size_t N>
constexpr int sum_constexpr(const int (&arr)[N]) {
    if constexpr (N == 0) return 0;
    else return arr[0] + sum_constexpr(arr + 1, N - 1);
}
// 调用：constexpr int s = sum_constexpr({1,2,3,4});

注意：递归深度受编译器限制（通常 512 层），可用 -fconstexpr-depth 调整，但应避免指数级递归。

方法五：利用 C++20 的 std::is_constant_evaluated()

该函数可在运行时判断当前是否在编译期求值上下文。通过它，你可以在同一个函数内提供两条路径：一条给编译期（纯函数），一条给运行时（可带副作用）。

#include <type_traits>

int compute(int x) {
    if (std::is_constant_evaluated()) {
        // 编译期执行：纯计算，无副作用
        return x * x;
    } else {
        // 运行时执行：可进行 I/O 等操作
        std::cout << "Runtime compute of " << x << '\n';
        return x * x;
    }
}

constexpr int compile_val = compute(3); // 调用编译期路径（不会打印）
int runtime_val = compute(5);          // 调用运行时路径（会打印）

关键动作：插入 if (std::is_constant_evaluated()) 分支，分离两种执行环境的逻辑。注意这个函数本身不能是 constexpr（因为编译期路径必须是纯计算），但可以放在非 constexpr 函数内。

编译期求值失败的典型诊断方法

当你的 constexpr 函数预期在编译期执行，但实际退化为运行时，可以：

1. 强制编译期求值：将调用结果赋值给 constexpr 变量（如 constexpr auto x = f(42);）。如果编译器报错，说明某些条件不满足，错误信息会指出具体违规点。

2. 使用 static_assert 检查：将函数调用放在 static_assert 的常量表达式中。

constexpr int f(int x) { return x * 2; }
static_assert(f(5) == 10, "f(5) should be 10"); // 编译期验证

3. 查看汇编或编译器输出：用 -O2 -S 等参数生成汇编，检查是否存在 call 指令调用该函数（若无则为编译期计算）。

最终核对清单（自检）

编写 constexpr 函数时，请逐条检查：

• [ ] 所有参数都是字面量类型吗？
• [ ] 函数体内没有 goto、try、asm 等禁止语句吗？
• [ ] 返回类型是字面量类型（或 void）吗？
• [ ] 调用的其他函数也都是 constexpr 吗？
• [ ] 没有修改全局/静态变量、传入的非 const 引用或指针吗？
• [ ] 没有动态内存分配（C++17）或遵循了 C++20 的分配限制吗？
• [ ] 没有 I/O 操作或异常抛出吗？
• [ ] 如果涉及递归，确保深度在编译器限制内吗？

满足以上所有条件，你的 constexpr 函数即可在编译期执行，实现零运行时开销。