编译期编程
现代 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 - 编译期排序、字符串验证、查找表生成等模式让"零运行时开销"真正可行