constexpr：C++编译期计算的基石

一、什么是constexpr？

constexpr是C++11引入的一个关键字，全称是 constant expression（常量表达式）。它告诉编译器和程序员：这个变量、函数或对象的值可以在编译期求值。

简单来说，constexpr让“计算”这件事可以从运行时提前到编译时完成。这意味着：

  • 编译时完成的计算，不占用程序的运行时间
  • 计算结果可以用于需要常量表达式的上下文（如数组大小、模板参数等）
  • 编译器可以在编译期进行更多的优化和检查

理解constexpr的关键是区分两个概念：编译期和运行期。传统C++中，大部分计算都发生在运行期——程序启动后才开始计算。而constexpr提供了一种方式，让某些计算在编译期就完成，程序运行时直接使用已经算好的结果。

二、constexpr的演进：C++11到C++20

constexpr不是一成不变的。它随着C++标准的演进而不断扩展，理解这个演进过程很重要。

标准版本constexpr能力
C++11首次引入。constexpr函数只能包含一个return语句，非常受限。
C++14大幅放宽限制。constexpr函数可以包含循环、分支、局部变量等。
C++17进一步扩展。允许constexpr lambda表达式，以及if constexpr（编译期条件判断）。
C++20革命性升级。允许constexpr动态内存分配、虚函数、std::vector等。consteval关键字独立出来。

从C++20开始，constexpr几乎覆盖了所有能在编译期执行的运算，标准库中大量的算法和容器都开始支持编译期使用。

三、constexpr变量

constexpr变量是最简单的用法。它表示变量的值必须在编译期已知。

constexpr int size = 10;                    // 编译期常量
constexpr double pi = 3.141592653589793;    // 编译期常量

// 用于数组大小（需要编译期常量）
int array[size];                            // OK

// 用于模板参数
std::array<int, size> arr;                  // OK

constexpr变量与const变量的区别：

const int a = get_value();          // const：运行时初始化也可以
constexpr int b = get_value();      // constexpr：必须在编译期初始化

// 如果 get_value() 是 constexpr 函数，两者都可以
// 如果 get_value() 是普通函数，只有 const 可以通过编译

核心区别：const只保证“不能修改”，而constexpr保证“值在编译期已知且不能修改”。所有的constexpr变量都是const，但反之不成立。

四、constexpr函数

4.1 基本概念

constexpr函数是一种特殊的函数：当它的参数在编译期已知时，该函数可以在编译期执行并返回编译期结果；如果参数在编译期未知，它也可以在运行期作为普通函数执行。

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

// 编译期执行：参数是编译期常量
constexpr int result = square(5);   // result = 25，编译期计算完成

// 运行期执行：参数是运行时变量
int runtime_value = 10;
int runtime_result = square(runtime_value);  // 运行期调用

这就是constexpr函数的妙处：一份代码，两种用途。编译期能用，运行期也能用。

4.2 C++11的约束（非常严格）

C++11中的constexpr函数只能包含一个return语句，不能包含循环和分支（三元运算符除外）。

// C++11 合法
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);   // 只能有这一个 return
}

// C++11 不合法（多个语句）
constexpr int bad(int n) {
    int result = 1;      // 错误：C++11不允许额外的语句
    for (int i = 2; i <= n; ++i) result *= i;
    return result;
}

4.3 C++14的突破（接近普通函数）

C++14大幅放宽了限制，constexpr函数现在可以包含：

// C++14 合法
constexpr int factorial(int n) {
    int result = 1;
    for (int i = 2; i <= n; ++i) {
        result *= i;
    }
    return result;
}

// 现在支持局部变量、循环、条件语句（if/switch）、甚至多个return
constexpr int abs_value(int x) {
    if (x < 0) {
        return -x;
    }
    return x;
}

4.4 C++20的飞跃（编译期向量与动态内存）

C++20允许constexpr函数中使用动态内存分配、虚函数调用、std::vector等。

// C++20 合法
constexpr int sum_vector() {
    std::vector<int> v = {1, 2, 3, 4, 5};  // C++20允许
    int sum = 0;
    for (int x : v) {
        sum += x;
    }
    return sum;
}

constexpr int result = sum_vector();  // result = 15，编译期完成

这意味着编译期能做的事情大大扩展了。不过需要注意：constexpr动态分配的内存必须在编译期完全释放，不能泄漏到运行时。

五、constexpr与const的区别

这是初学者最容易混淆的地方。以下对比表格清晰区分两者：

维度constconstexpr
核心含义“我不会修改这个值”“这个值可以在编译期求值”
适用对象变量、函数参数、成员函数变量、函数、构造函数、lambda
编译期必须可知否（可以在运行时初始化）是（必须在编译期初始化）
运行期存在是是
是否可以动态初始化可以不可以
是否隐含const仅变量本身为const变量本身为const，且编译期可知
// 展示区别的代码
int get_random() { return rand(); }

const int a = get_random();       // OK：运行时初始化
constexpr int b = get_random();   // 错误：get_random() 不是 constexpr

const int c = 42;                // OK，也是编译期常量
constexpr int d = 42;            // OK，也是编译期常量

// constexpr 变量也可以用于编译期上下文
constexpr int size = 100;
int arr[size];                    // OK

// const 变量只有在值编译期可知时才能用于编译期上下文
const int size2 = 100;
int arr2[size2];                  // OK，size2的值编译期已知

const int size3 = get_random();   // 运行时初始化
int arr3[size3];                  // 错误：size3不是编译期常量

六、constexpr构造函数的魅力

constexpr可以修饰构造函数，使得对象可以在编译期构造。

class Point {
public:
    constexpr Point(double x, double y) : x_(x), y_(y) {}
    constexpr double x() const { return x_; }
    constexpr double y() const { return y_; }
    constexpr double distance() const {
        return sqrt(x_ * x_ + y_ * y_);
    }
private:
    double x_;
    double y_;
};

// 编译期构造对象
constexpr Point p(3.0, 4.0);
constexpr double d = p.distance();  // d = 5.0，编译期计算完成

这开启了编译期面向对象编程的可能性。从C++20开始，constexpr构造函数甚至可以管理动态资源（如std::string）。

七、constexpr lambda表达式（C++17起）

C++17让lambda表达式也可以标记为constexpr，而且大多数lambda默认就是constexpr的。

// C++17 显式 constexpr lambda
auto square = [](int x) constexpr {
    return x * x;
};

constexpr int result = square(10);  // 编译期执行

// 大多数lambda默认是constexpr的
auto add = [](int a, int b) {
    return a + b;
};
constexpr int sum = add(3, 4);      // OK，编译期执行

八、if constexpr：编译期分支（C++17起）

if constexpr不是constexpr函数，而是编译期条件判断。它非常实用，值得一并介绍。

template <typename T>
auto get_value(T t) {
    if constexpr (std::is_pointer_v<T>) {
        return *t;   // 这个分支只在 T 是指针时编译
    } else {
        return t;    // 这个分支只在 T 不是指针时编译
    }
}

int x = 10;
int* p = &x;
std::cout << get_value(x) << std::endl;   // 10
std::cout << get_value(p) << std::endl;   // 10

if constexpr的优越性在于：不满足条件的分支根本不会被编译，而不是像普通if那样所有分支都要能通过编译。这在模板元编程中极其有用。

九、consteval：强制编译期执行（C++20起）

C++20引入了consteval关键字，它和constexpr的区别在于：

  • constexpr：函数可以在编译期执行（参数是常量时），也可以在运行期执行
  • consteval：函数必须在编译期执行，运行时不可调用
consteval int squared(int x) {
    return x * x;
}

constexpr int result = squared(5);   // OK：编译期执行
int runtime = 10;
int result2 = squared(runtime);      // 错误：runtime不是常量，无法编译期执行

consteval函数只产生编译期常量，它迫使程序员思考“这个值真的是编译期可知的吗？”，有助于提前发现设计问题。

十、constexpr与模板元编程的对比

模板元编程（Template Metaprogramming）是C++98时代实现编译期计算的主要方式，而constexpr提供了更自然、更易读的替代方案。

// 传统模板元编程：计算阶乘
template<int N>
struct Factorial {
    static constexpr int value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<0> {
    static constexpr int value = 1;
};

// 使用模板
constexpr int result1 = Factorial<5>::value;  // 120

// constexpr函数方式（更自然）
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

constexpr int result2 = factorial(5);  // 120，更直观

对比结论：

  • 模板元编程：函数式编程风格，类型运算，代码难写难读，编译期专用
  • constexpr：命令式/函数式风格，值运算，代码直观，编译运行通用

现代的C++倾向于使用constexpr替代传统的模板元编程，除非需要操作类型本身。

十一、constexpr的常见用途

11.1 编译期常量与数组大小

constexpr int BUFFER_SIZE = 1024;
char buffer[BUFFER_SIZE];

11.2 编译期计算（数学公式、表生成）

// 编译期生成正弦表
constexpr double deg_to_rad(double deg) {
    return deg * 3.141592653589793 / 180.0;
}

constexpr double SIN_TABLE[90] = {
    sin(deg_to_rad(0)),   // 所有这些值都在编译期计算
    sin(deg_to_rad(1)),
    // ...
};

11.3 编译期字符串处理

constexpr int string_length(const char* str) {
    int len = 0;
    while (str[len] != '\0') ++len;
    return len;
}

constexpr int len = string_length("Hello, World!");  // 13

11.4 编译期哈希计算

constexpr uint32_t fnv1a_hash(const char* str) {
    uint32_t hash = 0x811c9dc5u;
    while (*str) {
        hash ^= static_cast<uint8_t>(*str++);
        hash *= 0x01000193u;
    }
    return hash;
}

constexpr uint32_t HASH = fnv1a_hash("my_key");  // 编译期计算
// 可以用作编译期switch的case值

11.5 编译期配置（减少运行时开销）

// 编译期决定使用哪种算法
constexpr bool USE_SIMD = true;  // 编译期开关

template<typename T>
void process(T* data, size_t n) {
    if constexpr (USE_SIMD) {
        // SIMD优化版本，编译期决定是否包含
    } else {
        // 普通版本
    }
}

十二、constexpr的注意事项

12.1 不是所有操作都能在编译期执行

虽然C++20已经扩展了很多，但以下操作在constexpr函数中仍然受限：

  • 抛出异常（C++20允许，但会触发编译错误）
  • reinterpret_cast（地址不可编译期确定）
  • 调用运行时库函数（如printf、std::cout）
  • volatile操作
  • 某些系统调用

12.2 编译时间膨胀风险

constexpr函数在编译期执行大量计算会显著增加编译时间。如果计算量巨大（如编译期生成大规模表格），需要权衡编译时间和运行时性能。

12.3 递归深度限制

constexpr函数支持递归，但编译器有递归深度限制（通常为512层）。可以通过循环替代递归来规避。

12.4 调试困难

编译期的错误信息可能很复杂，不易理解。编译期调试工具（如static_assert）可以辅助。

十三、constexpr vs inline vs macro

维度constexprinlinemacro
计算时机编译期或运行期运行时展开预处理期文本替换
类型安全有有无
作用域遵守C++作用域规则遵守C++作用域规则全局文本替换
调试支持可调试（运行期调用时）可调试难以调试
编译期计算是否是（但通过文本替换实现）

结论：绝大多数情况下，constexpr是比inline函数和宏更好的选择。

十四、总结

constexpr是C++从“运行期语言”向“编译期可计算语言”演进的核心机制。它让程序员能够编写：

  1. 编译期常量：值在编译期确定，用于数组大小、模板参数等
  2. 编译期函数：一份代码，既能在编译期计算，也能在运行期调用
  3. 编译期对象：对象可以在编译期构造和使用
  4. 编译期逻辑：if constexpr实现编译期条件编译

从C++11的“仅单行return”，到C++14的“像普通函数一样”，再到C++20的“支持动态内存分配”，constexpr的演进极大地扩展了编译期编程的能力边界。

核心建议：

  1. 凡是值在编译期已知的变量，尽量使用constexpr而不是const
  2. 将简单的数学计算函数标记为constexpr，以提高性能
  3. 用constexpr函数替代传统的模板元编程
  4. 使用static_assert验证constexpr函数的结果是否符合预期
  5. 在性能关键的代码中，利用constexpr将计算前移到编译期

理解和掌握constexpr，意味着你能够写出更高效、更安全、更现代的C++代码。它让“零开销抽象”这个C++的核心哲学在编译期维度上得到了淋漓尽致的体现。

作者

老丹

关注我
其他文章