const强调不变性，constexpr强调编译时可确定性，所有constexpr都是const，但反之不成立；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 intvalue = 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
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
的“常量正确性”及其对代码维护的影响
“常量正确性”（
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
函数的限制与实用场景解析
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 = 120std::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;}
初始化
const
或
constexpr
变量：当需要用一个计算结果来初始化一个
const
或
constexpr
变量时，如果这个计算可以在编译时完成，那么使用 `constexpr
以上就是怎样声明和使用常量 const与constexpr关键字解析的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1470760.html
微信扫一扫 
支付宝扫一扫 
