C++中关键字constexpr的实现示例

constexpr 是 C++11 引入并在后续标准（C++14/C++17/C++20）中持续增强的关键字，其核心作用是在编译期计算常量或表达式，既保证了编译期的安全性检查，又能消除运行期计算的开销，是实现“零成本抽象”和编译期元编程的关键技术。

一、constexpr 的本质与核心目标

constexpr 的字面意思是“常量表达式（constant expression）”，它的设计目标有两个核心：

1. 编译期确定值：让变量、函数或对象的取值在编译阶段就能计算完成，避免运行时的冗余计算（如重复的数学运算、常量初始化）。
2. 强类型安全检查：强制编译器验证“是否满足编译期计算条件”，若存在运行时依赖（如动态输入、未初始化变量），则直接报错，避免潜在的逻辑错误。

从本质上看，constexpr 是对“常量”概念的强化——它不仅要求值“不可修改”，更要求值“可在编译期确定”，这是它与传统 const 最核心的区别。

二、constexpr 变量：编译期初始化的常量

constexpr 最基础的用法是修饰变量，要求变量在编译期完成初始化，且后续不可修改。

1. 变量声明的核心要求

• 必须在声明时初始化，且初始化表达式必须是常量表达式（即无运行时依赖的表达式）。
• 变量类型必须是“字面类型（Literal Type）”——即能通过 constexpr 构造函数初始化、无虚函数/虚基类、成员均为字面类型的类型（如 int、double、数组、满足条件的自定义类）。

正确示例

// 1. 基本类型：编译期计算 3+2 的结果（值为5）
constexpr int a = 3 + 2;
// 2. 数组：大小由 constexpr 变量确定（编译期已知）
constexpr size_t arr_size = 10;
int arr[arr_size]; // 合法，数组大小编译期确定
// 3. 常量表达式嵌套：依赖其他 constexpr 变量
constexpr int b = a * 4; // 编译期计算 5*4=20

错误示例

int x = 5;
// 错误：初始化表达式依赖运行时变量 x（非常量表达式）
constexpr int c = x + 3; 
// 错误：未初始化（constexpr 变量必须声明时初始化）
constexpr double d; 

2. 修饰指针与引用的特殊规则

constexpr 修饰指针/引用时，需明确“修饰的是指针本身”还是“指向的对象”，规则与 const 类似，但要求更严格（必须编译期确定地址）：

• constexpr 指针：指针本身是编译期常量（地址固定），指向的对象是否可修改需额外用 const 声明。

  int num = 10;
  // 错误：num 是栈上变量（地址运行时确定），无法作为 constexpr 指针的目标
  constexpr int* p1 = # 
  
  // 正确：全局变量地址编译期确定，p2 是 constexpr 指针（地址固定）
  int global_num = 20;
  constexpr int* p2 = &global_num; 
  // 正确：constexpr 指针 + const 对象（指针地址固定，指向的内容不可改）
  constexpr const int* p3 = &global_num; 
  

• constexpr 引用：引用的目标必须是编译期常量（地址固定），且引用本身不可重新绑定（与 const 引用一致，但要求更高）。

  // 正确：引用目标是 constexpr 变量（编译期常量）
  constexpr int e = 5;
  constexpr const int& ref = e; 
  

三、constexpr 函数：编译期可执行的函数

constexpr 函数是支持“编译期调用”的函数——当函数的实参是常量表达式时，函数会在编译期计算结果；若实参是运行时变量，则退化为普通函数在运行期执行（即“两态性”）。

const修饰的函数（修饰函数返回值或者函数类型）不可以因为constexpr的存才而删除，起到的作用不同，constexpr修饰作用可退回普通函数，但是const修饰的函数必定是常函数。

1. 函数声明的核心要求（随标准演进放宽）

constexpr 函数的限制在 C++11 到 C++20 中逐步放宽，核心要求如下：

2. 典型示例：编译期计算阶乘

// C++14 及以上：constexpr 函数支持循环
constexpr int factorial(int n) {
    if (n < 0) throw "n must be non-negative"; // C++20 允许 try-catch
    int result = 1;
    for (int i = 1; i <= n; ++i) {
        result *= i;
    }
    return result;
}

// 1. 编译期调用：实参是常量表达式（5），结果在编译期计算为 120
constexpr int f5 = factorial(5); 
// 2. 运行期调用：实参是运行时变量（x），结果在运行期计算
int x = 6;
int f6 = factorial(x); 

3. 关键特性：两态性与编译期验证

• 两态性：constexpr 函数并非“必须编译期执行”，而是“可编译期执行”。实参是常量表达式时编译期计算，否则运行期计算，兼顾灵活性与性能。
• 编译期验证：若强制要求函数在编译期执行（如赋值给 constexpr 变量），编译器会严格检查——若函数存在无法编译期执行的操作（如依赖运行时输入），则直接报错。

四、constexpr 类与对象：编译期构造的自定义类型

C++11 允许类通过 constexpr 构造函数 创建“编译期对象”，即对象的所有成员在编译期初始化，且对象的成员函数可通过 constexpr 修饰实现编译期调用。

1. constexpr 构造函数的要求

• 必须初始化类的所有非静态成员（确保无未初始化成员）。
• C++11 中函数体必须为空（仅通过初始化列表初始化）；C++14 及以上允许简单函数体（如条件判断）。
• 构造函数的参数必须是字面类型。

示例：编译期可构造的 Point 类

class Point {
private:
    int x_, y_;
public:
    // C++11 风格：空函数体，通过初始化列表初始化成员
    constexpr Point(int x, int y) : x_(x), y_(y) {}
    
    // constexpr 成员函数：编译期计算两点距离的平方
    constexpr int distance_sq(const Point& other) const {
        int dx = x_ - other.x_;
        int dy = y_ - other.y_;
        return dx*dx + dy*dy;
    }
    
    // 普通成员函数：仅运行期调用
    void print() const {
        std::cout << "(" << x_ << "," << y_ << ")\n";
    }
};

// 1. 编译期创建对象：构造函数实参是常量表达式
constexpr Point p1(1, 2);
constexpr Point p2(4, 6);
// 2. 编译期调用成员函数：计算距离平方（结果 25）
constexpr int dist_sq = p1.distance_sq(p2); 
// 3. 运行期调用普通成员函数
p1.print(); 

2. constexpr 对象的特性

• constexpr 对象的所有非静态成员均为编译期常量，可直接用于常量表达式（如作为 constexpr 函数的实参）。
• constexpr 对象的 this 指针在编译期可见，因此其 constexpr 成员函数可直接访问成员并完成编译期计算。

五、C++17/C++20 关键增强：constexpr lambda、consteval 与 constinit

随着标准演进，constexpr 的能力大幅扩展

1. C++17：constexpr lambda

C++17 允许 lambda 表达式通过 constexpr 修饰（或隐式满足 constexpr 条件），使其可在编译期执行。

示例：编译期使用 lambda 计算数组总和

#include <array>

constexpr auto sum_array = [](const auto& arr) {
    int sum = 0;
    for (auto val : arr) {
        sum += val;
    }
    return sum;
};

// 编译期计算数组总和：sum = 1+2+3+4+5 = 15
constexpr std::array<int, 5> arr = {1,2,3,4,5};
constexpr int total = sum_array(arr); 

2. C++20：consteval 与 constinit

C++20 新增两个关键字，进一步细化“编译期计算”的语义，与 constexpr 形成互补：

• consteval：强制函数“必须在编译期执行”（即“立即函数”），若无法编译期计算（如实参是运行时变量），直接报错。

  // consteval 函数：必须编译期执行
  consteval int square(int n) {
      return n * n;
  }
  
  constexpr int s4 = square(4); // 正确：编译期计算（16）
  int y = 5;
  // 错误：实参 y 是运行时变量，无法编译期执行
  int s5 = square(y); 
  

• constinit：确保变量“在编译期初始化”（仅适用于静态/线程局部变量），但不要求变量是“常量”（即后续可修改，只要初始化在编译期完成）。

  // 错误：静态变量默认运行时初始化（全局变量除外）
  static int static_num = 10; 
  // 正确：constinit 强制静态变量编译期初始化（值 20）
  constinit static int constinit_num = 20; 
  constinit_num = 30; // 合法：constinit 仅限制初始化，不限制后续修改
  

constexpr、consteval、constinit 对比

六、constexpr 的核心应用场景

constexpr 并非“语法糖”，而是解决实际问题的工具，核心应用场景包括：

1. 编译期计算：消除运行时开销

对于固定逻辑（如数学公式、常量配置），通过 constexpr 在编译期计算结果，避免运行时重复计算。例如：

• 编译期计算数组大小（替代 sizeof(arr)/sizeof(arr[0])）。
• 编译期生成哈希值（如字符串字面量的哈希，避免运行时哈希计算）。

2. 静态断言（static_assert）：编译期合法性检查

static_assert 的条件必须是常量表达式，constexpr 可提供复杂的编译期条件判断，实现更灵活的断言。例如：

// 编译期检查模板参数是否为偶数
template <int N>
void process() {
    static_assert(N % 2 == 0, "N must be even"); // 条件依赖 constexpr 计算
}

process<4>(); // 正确：4 是偶数
// process<5>(); // 错误：编译期断言失败，提示 "N must be even"

3. 编译期元编程：生成代码逻辑

结合模板与 constexpr，可在编译期生成代码（如循环展开、类型判断），实现“元编程”。例如：

• 编译期遍历数组并计算结果（无需运行时循环）。
• 编译期根据类型生成不同的处理逻辑（替代运行时 if-else）。

4. 常量表达式接口：增强类型安全

通过 constexpr 定义接口（如 constexpr 函数、constexpr 类），强制调用者使用编译期常量，避免运行时错误。例如：

• 自定义数值类型（如角度、长度），通过 constexpr 构造函数确保输入合法（如角度范围 0-360）。

七、常见误区与注意事项

1. “constexpr 变量一定在编译期存储”：错误。constexpr 仅要求“值在编译期确定”，存储位置仍由编译器决定（如可能存储在数据段，也可能直接内联到代码中）。
2. “constexpr 函数只能返回常量”：错误。constexpr 函数的返回值是否为常量，取决于实参——实参是常量表达式时返回常量，实参是运行时变量时返回普通值。
3. “constexpr 与 const 完全等价”：错误。const 仅表示“值不可修改”，不要求“值在编译期确定”（如 const int a = rand(); 是合法的，但 constexpr int a = rand(); 是错误的）；而 constexpr 同时要求“不可修改”和“编译期确定”。
4. “C++20 后 constexpr 可随意使用动态内存”：错误。C++20 允许 constexpr 函数使用 new，但必须在编译期通过 delete 释放（否则编译器报错），无法将动态内存泄露到运行时。

补充const与constexpr

const 和 constexpr 修饰函数时的作用和场景完全不同，核心区别在于：const 关注函数是否修改对象状态（仅用于成员函数），而 constexpr 关注函数是否能在编译时求值（可用于任意函数）。

1.const修饰函数（仅适用于类的非静态成员函数）

• 作用：声明该成员函数是“常量成员函数”，承诺不会修改对象的非静态数据成员，也不能调用非 const 的成员函数（防止间接修改对象）。
  本质是对函数的“行为约束”，确保调用该函数时对象状态不变，属于运行时的类型安全保障。

• 语法：const 放在函数参数列表后（const 成员函数的标志）。

  class A {
  private:
      int x;
  public:
      // const 成员函数：承诺不修改 x，也不能调用非 const 函数
      int getX() const { 
          // x = 10;  // 编译错误：const 函数不能修改成员
          return x; 
      }
  
      void setX(int val) {  // 非 const 函数：可以修改成员
          x = val; 
      }
  };
  

• 适用场景：
  当需要获取对象状态（如访问器 getter）但不修改它时，用 const 修饰，确保函数的“只读”行为。
  例如：const A a; a.getX(); 合法（const 对象只能调用 const 成员函数），但 a.setX(5); 会报错。

2.constexpr修饰函数（适用于任意函数：普通函数、成员函数、构造函数等）

• 作用：声明该函数是“常量表达式函数”，可以在编译时被求值（前提是输入参数为常量表达式）。
  本质是对函数的“计算时机约束”，允许函数结果作为编译期常量使用（如模板参数、数组大小等），属于编译时的计算能力保障。

• 语法：constexpr 放在函数返回类型前。

  // 普通 constexpr 函数：编译时可求值
  constexpr int add(int a, int b) {
      return a + b;
  }
  
  class B {
  private:
      int y;
  public:
      // constexpr 构造函数：允许创建编译期对象
      constexpr B(int val) : y(val) {}
  
      // constexpr 成员函数：编译时可求值（需满足条件）
      constexpr int getY() const {  // 可同时是 const（双重约束）
          return y;
      }
  };
  

• 适用场景：
  当需要在编译时计算结果（如常量、模板参数）时，用 constexpr 修饰。例如：

  constexpr int sum = add(3, 5);  // 编译时计算，sum 是编译期常量（8）
  constexpr B b(10);             // 编译期创建对象
  int arr[b.getY()];             // 合法：数组大小是编译期常量（10）
  

  注意：constexpr 函数并非只能在编译时调用，当输入参数是运行时变量时，它也能像普通函数一样在运行时调用。

3. 核心对比表

• 用 const 修饰成员函数：告诉编译器和使用者“这个函数不会改对象，放心在 const 对象上调用”。
• 用 constexpr 修饰函数：告诉编译器“这个函数可以在编译时算，给我编译期优化的能力”。
• 两者可以共存（如 constexpr const 成员函数），此时函数既保证不修改对象，又能在编译时求值。

到此这篇关于C++中关键字constexpr的实现示例的文章就介绍到这了,更多相关C++ 关键字constexpr内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！ 

最新评论