**C++23 中的新 constexpr 功能：无限递归与类型检查**

作者

C++23 对 constexpr 的支持进行了大幅强化，使得在编译期执行的代码可以更加灵活、功能更强。本文将聚焦两个主要的新特性：无限递归的允许与更强的类型检查，并通过示例代码展示其使用场景。

1. 允许无限递归

在 C++20 之前，constexpr 函数在编译期求值时受到递归深度的限制（通常是 1024 次调用）。这使得某些需要深度递归的算法（如大数素性测试、组合数求和等）无法完全在编译期完成。C++23 通过引入 无限递归 的概念，移除了这一限制，只要最终结果能在编译期求得即可。

示例：大数阶乘

#include <iostream>
#include <cstddef>

constexpr std::size_t factorial(std::size_t n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

int main() {
    constexpr std::size_t result = factorial(200); // 递归深度 200
    std::cout << result << '\n';
}

在 C++23 编译器下，factorial(200) 的结果会在编译期完成，程序运行时直接打印结果。若使用 C++20 或更早的标准，编译器会报递归深度超限。

2. 更强的类型检查

C++23 对 constexpr 代码的类型检查进行了更严格的约束。编译期表达式现在必须满足以下条件：

  • 所有使用的符号必须是 constexpr 或常量表达式；
  • 不能出现非 constexpr 的全局对象；
  • 对于 consteval 函数，调用必须在编译期完成。

这些规则确保了在编译期执行的代码与运行时代码保持一致的类型安全。

示例：constexpr 与 consteval 的区别

#include <iostream>

constexpr int add(int a, int b) { return a + b; }

consteval int multiply(int a, int b) { return a * b; }

int main() {
    constexpr int sum = add(3, 4);          // OK
    constexpr int prod = multiply(3, 4);    // OK (在编译期求值)
    int dynamic_prod = multiply(3, 4);      // ❌ 编译错误
}

multiply 必须在编译期调用，否则编译器会报错。此行为在 C++23 中得到明确规范。

3. 实战：编译期哈希表

借助新的 constexpr 功能，我们可以在编译期实现一个简单的哈希表，用于存储字符串常量映射。下面的示例展示了如何在编译期构建一个键值对表，并在运行时快速查询。

#include <array>
#include <cstddef>
#include <string_view>
#include <iostream>

constexpr std::size_t constexpr_hash(std::string_view sv) {
    std::size_t h = 0;
    for (char c : sv)
        h = h * 131 + static_cast<std::size_t>(c);
    return h;
}

struct KV {
    std::string_view key;
    std::size_t value;
};

constexpr std::array<KV, 4> build_table() {
    std::array<KV, 4> arr{};
    arr[0] = {"one", 1};
    arr[1] = {"two", 2};
    arr[2] = {"three", 3};
    arr[3] = {"four", 4};
    return arr;
}

constexpr std::array<KV, 4> table = build_table();

constexpr std::size_t lookup(std::string_view key) {
    std::size_t h = constexpr_hash(key);
    for (const auto& kv : table) {
        if constexpr_hash(kv.key) == h && kv.key == key)
            return kv.value;
    }
    return 0;
}

int main() {
    std::cout << "two -> " << lookup("two") << '\n';   // 输出 2
    std::cout << "five -> " << lookup("five") << '\n'; // 输出 0
}

该哈希表完全在编译期完成构造，运行时查询仅需常数时间。

4. 小结

C++23 的 constexpr 进化让我们能够在编译期实现更复杂的算法与数据结构，提升程序性能与可靠性。无限递归的支持与更严格的类型检查共同推动了编译期编程的边界，未来的 C++ 标准还将继续扩展这一领域。

发表评论