编译期编程

现代 C++ 的一大核心思想是"尽可能在编译期完成计算"。编译期编程不仅能提升运行时性能(零成本抽象的极致体现),还能在编译阶段捕获错误,让程序更安全、更可预测。本章将系统介绍 constexpr、consteval、constinit 以及 if constexpr 等编译期编程设施。

1. constexpr 函数

constexpr 函数是"两栖"函数:当参数是编译期常量时,在编译期求值;否则退化为普通运行时函数。这使得你只需写一份代码就能同时服务于两种场景。

// 最经典的示例:编译期阶乘
constexpr int factorial(int n) {
    int result = 1;
    for (int i = 2; i > n;
std::cout << factorial(n) << '\n';  // 运行时计算

C++ 各版本对 constexpr 函数的放宽:

  • C++11:函数体只能有一个 return 语句(极其受限)
  • C++14:允许循环、局部变量、多个 return
  • C++17:允许 if constexpr
  • C++20:允许 try-catch、虚函数、动态内存分配(transient)
  • C++23:更多标准库函数标记为 constexpr(如 std::unique_ptr)

一个更实用的例子——编译期计算字符串哈希:

constexpr std::uint32_t fnv1a_hash(std::string_view sv) {
    std::uint32_t hash = 2166136261u;
    for (char c : sv) {
        hash ^= static_cast(c);
        hash *= 16777619u;
    }
    return hash;
}

// 编译期获得字符串的哈希值,可用于 switch-case
constexpr auto h = fnv1a_hash("hello");
static_assert(h == fnv1a_hash("hello"));  // 确定性

2. consteval — 强制编译期求值

C++20 引入 consteval 关键字,标记"即时函数"(immediate function)。与 constexpr 不同,consteval 函数必须在编译期求值,如果传入运行时变量则编译失败。

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

constexpr int a = square(4);   // OK: 编译期求值,a == 16
int b = square(5);             // OK: 5 是字面量,编译期求值

int runtime_val = 7;
// int c = square(runtime_val);  // 编译错误!consteval 不接受运行时值

consteval 的典型应用场景:

// 用例 1:编译期格式串验证
consteval bool validate_format(std::string_view fmt) {
    int open = 0;
    for (char c : fmt) {
        if (c == '{') ++open;
        if (c == '}') --open;
        if (open 
struct FormatString {
    char data[N];
    consteval FormatString(const char (&str)[N]) {
        std::copy_n(str, N, data);
        if (!validate_format(str)) {
            throw "invalid format string";  // 编译错误
        }
    }
};

// 用例 2:编译期查找表生成
consteval auto make_sin_table() {
    std::array table{};
    for (int i = 0; i < 360; ++i) {
        double rad = i * 3.14159265358979 / 180.0;
        // 简化的泰勒展开(实际可用更精确的算法)
        double x = rad;
        double term = rad;
        double sum = rad;
        for (int n = 1; n < 10; ++n) {
            term *= -rad * rad / ((2*n) * (2*n + 1));
            sum += term;
        }
        table[i] = sum;
    }
    return table;
}

// 编译期生成,运行时直接查表
constexpr auto sin_table = make_sin_table();

consteval 函数不能取地址。因为即时函数在编译后不存在于二进制中,你无法获取函数指针或通过引用传递 consteval 函数。如果需要同时支持编译期和运行时调用,请使用 constexpr。

3. constinit — 编译期初始化保证

constinit(C++20)确保静态存储期或线程局部变量在编译期初始化,从而避免臭名昭著的"静态初始化顺序灾难"(static initialization order fiasco)。

// 全局变量:constinit 保证编译期初始化
constinit int global_count = 42;         // OK
constinit double pi = 3.14159;           // OK

// 错误示例:
// constinit int bad = some_runtime_function();  // 编译错误!

// 关键区别:constinit 变量可以在运行时修改!
void increment() {
    ++global_count;  // 完全合法
}

// 对比 constexpr:
constexpr int ce_val = 42;
// ce_val = 100;  // 错误:constexpr 变量是 const 的

静态初始化顺序灾难示例:

// file_a.cpp
int compute_initial() { return 42; }
int global_a = compute_initial();  // 运行时初始化,顺序不确定

// file_b.cpp
extern int global_a;
int global_b = global_a + 1;  // 危险!global_a 可能还没初始化

// 修复方案:使用 constinit
constinit int safe_a = 42;  // 保证在编译期就已初始化
// 其他翻译单元使用 safe_a 是安全的

constinit 与 thread_local:constinit thread_local 是常见组合,确保线程局部变量在每个线程启动时以编译期常量初始化,而非执行动态初始化代码。

4. if constexpr — 编译期分支

if constexpr(C++17)是编译期条件语句。条件为 false 的分支会被丢弃(discarded statement),不会被编译,也不需要对当前类型合法。这是替代标签分发(tag dispatch)和 SFINAE 的利器。

// 根据类型选择不同序列化策略
template
std::string serialize(const T& value) {
    if constexpr (std::is_integral_v) {
        return std::to_string(value);
    } else if constexpr (std::is_floating_point_v) {
        // 浮点数保留 6 位精度
        std::ostringstream oss;
        oss ) {
        return "\"" + value + "\"";
    } else {
        static_assert(false, "Unsupported type for serialization");
    }
}

auto s1 = serialize(42);          // "42"
auto s2 = serialize(3.14);        // "3.140000"
auto s3 = serialize(std::string("hi"));  // "\"hi\""

对比传统 SFINAE 写法,if constexpr 的优势非常明显:

// 传统 SFINAE(难读、难维护)
template
std::enable_if_t, std::string>
serialize_old(const T& value) {
    return std::to_string(value);
}

template
std::enable_if_t, std::string>
serialize_old(const T& value) {
    // ...
}

// if constexpr 版本:一个函数搞定,逻辑集中清晰

结合可变参数模板的递归终止:

template
void print_all(const T& first, const Rest&... rest) {
    std::cout  0) {
        std::cout << ", ";
        print_all(rest...);  // 递归展开
    }
    // 当 rest 为空时,这个分支被丢弃,递归自然终止
}

print_all(1, "hello", 3.14);  // 输出: 1, hello, 3.14

if constexpr 的条件必须是编译期布尔值。不能写 if constexpr (x > 0) 其中 x 是运行时变量。条件通常是 type traits、sizeof...、constexpr 变量等。

5. constexpr 容器(C++20)

C++20 的一项重大突破:std::vector 和 std::string 可以在 constexpr 上下文中使用。这依赖于"瞬态分配"(transient allocation)机制——在编译期分配的内存必须在编译期求值结束前释放。

// C++20:constexpr 中使用 vector
constexpr int sum_of_squares(int n) {
    std::vector v;
    for (int i = 1; i <= n; ++i) {
        v.push_back(i * i);
    }
    int sum = 0;
    for (int x : v) sum += x;
    return sum;
    // v 在这里被销毁,内存释放 —— 满足 transient allocation
}

static_assert(sum_of_squares(3) == 14);  // 1 + 4 + 9

// constexpr string 处理
constexpr std::string make_greeting(std::string_view name) {
    std::string result = "Hello, ";
    result += name;
    result += "!";
    return result;  // 注意:返回值的内存也必须是 transient 的
}

瞬态分配规则:编译期分配的堆内存不能"逃逸"到运行时。如果你想保存编译期计算的结果,需要将其存入 std::array 等固定大小的容器中:

// 将编译期 vector 结果转换为 array
consteval auto make_primes() {
    // 编译期用 vector 做计算
    std::vector primes;
    for (int n = 2; primes.size()  result{};
    std::copy(primes.begin(), primes.end(), result.begin());
    return result;
    // vector 在此销毁,满足 transient 要求
}

constexpr auto first_10_primes = make_primes();
// first_10_primes == {2, 3, 5, 7, 11, 13, 17, 19, 23, 29}

6. 编译期计算实例

6.1 编译期 Fibonacci

constexpr long long fibonacci(int n) {
    if (n  table{};
    for (int i = 0; i < 50; ++i) {
        table[i] = fibonacci(i);
    }
    return table;
}

constexpr auto fib_table = make_fib_table();

6.2 编译期字符串验证

// 编译期验证 IPv4 地址格式
consteval bool is_valid_ipv4(std::string_view ip) {
    int parts = 0;
    int current = 0;
    int digits = 0;

    for (char c : ip) {
        if (c == '.') {
            if (digits == 0 || current > 255) return false;
            ++parts;
            current = 0;
            digits = 0;
        } else if (c >= '0' && c  3) return false;
        } else {
            return false;
        }
    }

    return parts == 3 && digits > 0 && current <= 255;
}

// 编译期验证,错误立即报告
static_assert(is_valid_ipv4("192.168.1.1"));
static_assert(is_valid_ipv4("10.0.0.255"));
static_assert(!is_valid_ipv4("256.1.1.1"));
static_assert(!is_valid_ipv4("1.2.3"));
static_assert(!is_valid_ipv4("1.2.3.4.5"));

6.3 编译期排序

// 编译期冒泡排序(用于小数组)
template
consteval std::array compile_time_sort(std::array arr) {
    for (std::size_t i = 0; i < N; ++i) {
        for (std::size_t j = i + 1; j < N; ++j) {
            if (arr[j] < arr[i]) {
                auto tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
    return arr;
}

constexpr auto unsorted = std::array{5, 2, 8, 1, 9, 3};
constexpr auto sorted = compile_time_sort(unsorted);
// sorted == {1, 2, 3, 5, 8, 9}  — 排序在编译期完成!

static_assert(sorted[0] == 1);
static_assert(sorted[5] == 9);

6.4 编译期查找表与映射

// 编译期构建 ASCII 分类表
consteval auto make_char_class_table() {
    std::array table{};
    for (int c = 0; c = '0' && c = 'a' && c = 'A' && c (c)] == 2
        || char_class[static_cast(c)] == 3;
}

7. constexpr vs consteval vs constinit 对比

特性 constexpr consteval constinit
引入版本 C++11 C++20 C++20
适用于 函数、变量 函数 变量(static/thread_local)
编译期求值 可以(不强制) 必须 初始化必须
运行时调用 可以 不可以 N/A(不是函数)
变量可修改 不可以(隐含 const) N/A 可以
存在于二进制 可能(视调用方式) 不存在 存在
典型用途 通用编译期/运行时计算 代码生成、验证 防止静态初始化灾难

选择指南:

// constexpr:两栖函数,编译期+运行时都可用
constexpr int add(int a, int b) { return a + b; }

// consteval:只在编译期使用,运行时不存在
consteval int compile_only(int x) { return x * x; }

// constinit:保证初始化时机,但允许后续修改
constinit int counter = 0;  // 编译期初始化
// 后续可以 ++counter

经验法则:优先使用 constexpr,它最灵活。仅在你明确需要"禁止运行时调用"时使用 consteval(例如编译期验证逻辑)。对于全局/静态变量的初始化安全性,使用 constinit。

本章小结

  • constexpr 函数是两栖的:编译期常量参数触发编译期求值,否则运行时执行;C++14/17/20 持续放宽限制
  • consteval 标记即时函数,强制编译期求值,适合验证逻辑和查找表生成
  • constinit 保证静态/线程局部变量在编译期初始化,解决静态初始化顺序问题,且允许后续修改
  • if constexpr 实现编译期分支,丢弃无效分支,替代 SFINAE 和标签分发
  • C++20 支持 constexpr std::vector/std::string(瞬态分配),结果需转存到 std::array
  • 编译期排序、字符串验证、查找表生成等模式让"零运行时开销"真正可行