const与constexpr常量使用全解析

作者：水悠悠予安时间：2025-12-13 来源：正软商城浏览：10

const强调不变性，constexpr强调编译时可确定性，所有constexpr都是const，但反之不成立；const变量可在运行时初始化，而constexpr必须在编译时求值；选择const用于运行期不变值，选择constexpr用于需编译时常量的场景如数组大小、模板参数或编译时计算，以提升性能和类型安全。

本文目录

怎样声明和使用常量 const与constexpr关键字解析

在C++中，const 关键字用来声明一个变量的值在初始化后不能被修改，它确保了“只读”的特性，可以是编译期常量，也可以是运行期常量。而 constexpr 关键字则更进一步，它强制要求被声明的变量或函数的值必须在编译时就能确定。简单来说，constexpr 是 const 的一个更严格的子集，它不仅保证了不变性，还保证了编译时可计算性。

解决方案

理解 const 和 constexpr 的核心在于它们对“不变性”和“何时确定值”的不同承诺。

const 关键字：不变的承诺

const 的本意是“常量”，但它在C++中的含义远不止于此。它是一个类型修饰符，告诉编译器和读者，被 const 修饰的东西在初始化之后就不能再改变了。这不仅仅是为了防止意外修改，更是为了表达一种意图，一种契约。

修饰变量： 这是最常见的用法。
```
const int max_attempts = 3; // 编译期常量
int user_input = getUserInput();
const int current_value = user_input; // 运行期常量
```
max_attempts 在编译时就确定了，而 current_value 则在运行时根据 user_input 的值确定，但一旦确定，它就不能再被修改了。

修饰指针和引用： 这是 const 比较容易让人混淆的地方。

指向常量的指针 (const Type* ptr 或 Type const* ptr): 指针指向的内容是常量，不能通过这个指针修改它指向的值。

int value = 10;
const int* ptr_to_const = &value; // 可以指向非const变量，但不能通过ptr_to_const修改value
// *ptr_to_const = 20; // 错误：不能修改const int
value = 20; // 正确：value本身不是const

*常量指针 (`Type const ptr`):** 指针本身是常量，一旦初始化，它就不能再指向其他地方。

int value1 = 10;
int value2 = 20;
int* const const_ptr = &value1; // const_ptr 总是指向 value1
*const_ptr = 15; // 正确：可以通过const_ptr修改value1
// const_ptr = &value2; // 错误：不能改变const_ptr指向

*指向常量的常量指针 (`const Type const ptr`):** 指针本身和它指向的内容都是常量。

int value = 10;
const int* const const_ptr_to_const = &value;
// *const_ptr_to_const = 20; // 错误
// const_ptr_to_const = &another_value; // 错误

const 引用 (const Type& ref): 引用一旦绑定就不能改变，const 引用则表示不能通过这个引用修改它所引用的对象。
```
int x = 5;
const int& ref_to_x = x;
// ref_to_x = 10; // 错误
x = 10; // 正确，x本身不是const
```

修饰成员函数： 放在函数签名后面，表示这个成员函数不会修改对象的状态（即不会修改非静态成员变量）。
```
class MyClass {
public:
    int get_value() const { // const成员函数
        // value_++; // 错误：不能修改成员变量
        return value_;
    }
private:
    int value_ = 0;
};
```
这对于确保对象的不变性非常重要，尤其是在多线程环境中，或者当你将对象作为 const 引用传递时。

constexpr 关键字：编译时求值的保证

constexpr 是 C++11 引入的，它代表“常量表达式”。它的核心思想是：如果一个值在编译时就可以确定，那么就让它在编译时计算出来。这带来了性能优化（运行时无需计算），也使得一些高级特性成为可能（如模板元编程、在编译时确定数组大小）。

修饰变量： 声明的变量必须在编译时就能确定其值。
```
constexpr int max_size = 100; // 编译时常量
// constexpr int runtime_value = getUserInput(); // 错误：getUserInput()是运行时函数
```
所有 constexpr 变量都是 const 的，但反之不然。一个 const 变量可能在运行时才初始化，但 constexpr 变量必须在编译时初始化。
修饰函数： constexpr 函数可以在编译时被求值，如果它的所有参数都是编译时常量。如果参数不是编译时常量，它仍然可以作为普通函数在运行时求值。
```
constexpr int square(int n) {
    return n * n;
}

int main() {
    constexpr int s1 = square(5); // 编译时求值，s1 = 25
    int x = 6;
    int s2 = square(x); // 运行时求值，s2 = 36
    // static_assert(square(4) == 16, "Compile-time check failed!"); // 编译时断言
}
```
constexpr 函数有一些限制，比如在 C++11 中，函数体必须非常简单，只能有一个 return 语句。但从 C++14 开始，这些限制大大放宽，允许包含 if 语句、循环、局部变量等，这让 constexpr 函数变得更加实用。

修饰构造函数： 允许在编译时创建类的实例。

class Point {
public:
    constexpr Point(double x, double y) : x_(x), y_(y) {}
    constexpr double get_x() const { return x_; }
    constexpr double get_y() const { return y_; }
private:
    double x_;
    double y_;
};

constexpr Point p(10.0, 20.0); // 编译时创建对象

总结： const 强调“不变性”，而 constexpr 强调“编译时可确定性”。当你需要一个值在编译时就固定下来，并且可能用于需要编译时常量的场景（如数组大小、模板参数），那么 constexpr 是你的选择。如果只是想确保一个变量在初始化后不再被修改，const 就足够了。

`const` 和 `constexpr` 在实际项目中如何选择？

这确实是一个好问题，很多时候我也会在两者之间犹豫。在我看来，选择 const 还是 constexpr，主要取决于你对“不变性”的“严格程度”和“何时确定”的要求。

首先，一个基本原则是：如果一个变量的值在初始化后不应该改变，那就用 const 修饰它。 这是最基本的安全和意图表达。它能帮助编译器发现潜在的错误，也能让代码的读者一眼看出这个变量的生命周期里不会变。比如，一个配置文件中读取的阈值，或者一个循环次数，即使它是在运行时从文件或用户输入中获取的，一旦获取并赋值，如果后续不应修改，就应该用 const。

然后，再考虑 constexpr。当你需要一个值在编译时就完全确定，并且这个值可能用于需要编译时常量的上下文时，就应该使用 constexpr。 常见的场景包括：

数组的维度： int arr[N]; 这里的 N 必须是编译时常量。
模板的非类型参数： template class MyContainer; 这里的 N 也必须是编译时常量。
编译时计算： 比如一个复杂的数学公式，或者一个哈希值，如果能在编译时就算好，就能避免运行时的开销。这对于性能敏感的代码特别有用。
static_assert： 编译时断言的条件必须是编译时常量表达式。

我个人的习惯是，如果一个值是真正的“数学常量”或者“硬编码”的配置值，我会倾向于使用 constexpr。比如圆周率 M_PI，或者一个固定的缓冲区大小。因为它们不仅不变，而且其值在程序编译之前就已经确定了。而对于那些在程序启动或运行过程中才确定的“不变”值，const 就足够了。

有时候，我会先用 const，如果后续发现有需要它在编译时确定的场景（比如需要用它来定义一个 std::array 的大小），我才会把它升级为 constexpr。毕竟，constexpr 意味着更严格的限制，并不是所有函数都能被声明为 constexpr 的。这种迭代式的决策，让我在保持代码灵活性的同时，也能逐步提升其性能和安全性。

深入理解 `const` 的“常量正确性”及其对代码维护的影响

“常量正确性”（const correctness）是C++编程中一个非常重要的概念，它不仅仅是语法上的规定，更是一种设计哲学。它指的是在代码中正确、一致地使用 const 关键字，以确保对数据的访问权限得到恰当的控制，并明确表达程序的意图。

在我看来，掌握 const 正确性是区分一个C++程序员是否真正理解这门语言的关键点之一。它带来的好处是多方面的，对代码的长期维护影响深远：

提升代码可读性与意图表达： 当你看到一个函数参数是 const std::string& name，你立刻就知道这个函数不会修改 name 的内容。同样，一个 const 成员函数明确告诉我们，调用它不会改变对象的状态。这种清晰的意图表达，大大降低了代码理解的认知负担，减少了“阅读代码猜行为”的时间。
增强代码安全性，减少Bug： const 关键字是编译器层面的保护伞。如果你不小心尝试修改一个 const 对象，编译器会立即报错。这能有效防止许多潜在的逻辑错误，比如在一个复杂的函数中意外地修改了不该修改的数据。尤其是在大型项目中，多个开发者协作时，const 能够强制执行数据不变性，避免了许多难以追踪的副作用。
促进编译器优化： 编译器知道一个变量是 const 的，它就可以做一些更激进的优化。例如，它可以将 const 变量存储在只读内存区域，或者在多次访问时直接使用寄存器中的缓存值，而无需担心数据被修改。虽然现代编译器已经非常智能，但明确的 const 标记仍然能为它们提供宝贵的优化线索。
改善API设计与接口契约： 在设计库或模块的公共接口时，const 正确性至关重要。一个函数如果承诺不修改传入的对象，就应该将参数声明为 const 引用或 const 指针。这为库的用户提供了清晰的保证，他们可以放心地传递 const 对象，而不用担心其内部状态被意外改变。这使得你的API更健壮、更易用。
支持多线程编程： 虽然 const 本身不直接提供线程安全，但 const 数据是天然的线程安全读取对象。因为它们不会改变，所以多个线程可以同时安全地读取它们，无需加锁。这简化了并发编程的复杂性，减少了死锁和竞态条件的风险。当然，如果 const 对象内部包含 mutable 成员，或者通过 const_cast 进行了类型转换，那么线程安全就需要重新评估了。

挑战与 mutable 关键字：

尽管 const 正确性带来了诸多好处，但在某些特定情况下，它也可能带来一些设计上的挑战。最常见的例子就是缓存或惰性初始化。一个 const 成员函数按理说不能修改任何成员变量，但如果这个函数内部需要缓存计算结果，或者需要惰性地初始化一个互斥锁，这就与 const 的语义冲突了。

这时，mutable 关键字就派上用场了。mutable 成员变量即使在一个 const 成员函数中也可以被修改。

class DataProcessor {
public:
    int get_processed_data() const {
        if (!cache_valid_) {
            // 假设这里执行耗时计算，并更新cache_
            // 尽管是const函数，但mutable成员可以修改
            cache_ = expensive_computation();
            cache_valid_ = true; // 修改mutable成员
        }
        return cache_;
    }
private:
    mutable int cache_; // 声明为mutable
    mutable bool cache_valid_ = false; // 声明为mutable
    int raw_data_;
};

使用 mutable 是一种“逃生舱”，它允许你在保持外部 const 契约的同时，在内部进行一些状态管理。但我会非常谨慎地使用它，因为它在某种程度上打破了 const 的纯粹性。滥用 mutable 会让代码的意图变得模糊，反而增加了维护的难度。只有当内部状态的改变不影响对象的外部逻辑行为时，才考虑使用 mutable。

总而言之，const 正确性是C++中一个强大的工具，它通过编译器的强制执行，帮助我们编写出更安全、更易读、更健壮的代码。在日常开发中，我总是鼓励团队成员尽可能地使用 const，让它成为一种习惯。

`constexpr` 函数的限制与实用场景解析

constexpr 函数是 C++11 引入的一项强大特性，它允许函数在编译时求值，从而在运行时节省开销，并支持一些需要编译时常量的编程模式。然而，为了确保编译时求值的可行性，constexpr 函数也带有一些特定的限制。

constexpr 函数的限制：

最初在 C++11 中，constexpr 函数的限制非常严格，函数体几乎只能包含一个 return 语句。这使得它在实际应用中显得有些笨拙。但从 C++14 开始，这些限制大大放宽，使其变得更加实用：

C++11 限制（历史回顾）：
- 函数体必须是单个 return 语句。
- 不能包含变量声明（除了参数）。
- 不能包含 if、switch、循环、try-catch 等控制流语句。
C++14 及更高版本（更宽松，更实用）：
- 允许局部变量： 可以在函数内部声明局部变量。
- 允许 if 和 switch 语句： 可以包含条件分支。
- 允许循环： for、while、do-while 循环都可以使用。
- 允许表达式语句： 比如赋值操作。
- 不允许副作用： constexpr 函数不能有可见的副作用，例如修改非局部变量、执行 I/O 操作、动态内存分配（new/delete）。
- 不能抛出异常： constexpr 函数不能包含 throw 表达式。
- 不能使用 goto 语句。
- 参数和返回值必须是字面量类型： 简单来说，就是可以在编译时确定大小和值的类型（如整型、浮点型、引用、枚举、用户定义的字面量类型）。

尽管限制有所放宽，但核心思想不变：constexpr 函数的执行路径必须能在编译时完全确定，并且不能依赖任何运行时行为或产生运行时副作用。

constexpr 函数的实用场景：

正是由于其编译时求值的特性，constexpr 函数在某些场景下显得非常有用：

编译时常量计算： 这是最直接的用途。任何可以在编译时完成的计算，比如阶乘、斐波那契数列、幂运算、单位转换等，都可以用 constexpr 函数来实现，从而避免运行时开销。

constexpr long long factorial(int n) {
    long long res = 1;
    for (int i = 1; i <= n; ++i) {
        res *= i;
    }
    return res;
}
// ...
constexpr long long f5 = factorial(5); // 编译时计算，f5 = 120
std::array arr; // 数组大小在编译时确定

用于模板元编程：constexpr 函数为模板元编程提供了更简洁、更可读的替代方案。以前需要复杂的模板特化和递归来实现的编译时计算，现在可以用更像普通函数的方式来编写。

编译时字符串处理和哈希： 从 C++17 开始，constexpr 字符串视图（std::string_view）和相关的操作使得在编译时处理字符串成为可能。这对于实现编译时字符串哈希（例如用于 switch 语句或映射查找）非常有用。

#include 
#include 

// 编译时字符串哈希函数
constexpr unsigned int string_hash(std::string_view s) {
    unsigned int hash = 0;
    for (char c : s) {
        hash = (hash * 31) + c; // 简单的哈希算法
    }
    return hash;
}

// ...
switch (string_hash("command_a")) { // switch语句的case标签需要编译时常量
    case string_hash("command_a"): // 编译时计算哈希值
        // ...
        break;
    case string_hash("command_b"):
        // ...
        break;
    default:
        break;
}