C++ const 常量：const、constexpr 与 consteval

为什么需要常量

常量是一个你承诺设定之后就不再改变的值。把某个东西标记为 const 同时做了两件事：它向读代码的人说明了你的意图，也让编译器来强制执行这个意图。任何试图修改这个值的代码都会变成编译错误，而不是一个悄无声息的运行时 bug。

auto 关键字让编译器推断变量的类型，而 const 限制的是你能对这个变量做什么。两者可以自由组合：const auto limit = 100; 就是一个只读的 int。

声明 const 值

把 const 写在类型前面。const 变量必须在同一行初始化，因为之后再也没有允许你给它赋值的时机。

#include <iostream>
using namespace std;

int main() {
    const int maxUsers = 100;
    const double pi = 3.14159;

    cout << "Max users: " << maxUsers << "\n";
    cout << "Pi: " << pi << "\n";

    // maxUsers = 200; // error: assignment of read-only variable
    return 0;
}

取消那行赋值的注释，程序就无法编译，编译器会报告“assignment of read-only variable”。这正是目的所在：错误在程序运行之前就被发现了。

从 C 带过来的一个常见新手习惯是写 #define MAX_USERS 100。不要这样做。宏只是盲目的文本替换，没有类型，也不遵守作用域，所以没法在调试器里查看，出错时的错误信息也让人摸不着头脑。const（或 constexpr）变量会像其他变量一样做类型检查，也有自己的作用域。

const 与 constexpr

两个关键字都能得到一个不能改变的值，但它们回答的是不同的问题。const 说的是“设定之后就不再改变”。constexpr 说的更进一步：“这个值能在编译期算出来”。而且任何 constexpr 的东西自动也是 const。

#include <iostream>
using namespace std;

int main() {
    int n = 5;
    const int a = n;          // OK: runtime value, just read-only
    constexpr int b = 10;     // OK: known at compile time
    // constexpr int c = n;   // error: n is not a compile-time constant

    int grid[b];              // legal: array size must be a compile-time constant
    cout << "Array length: " << sizeof(grid) / sizeof(grid[0]) << "\n";
    cout << a << " " << b << "\n";
    return 0;
}

经验法则：只要值是一个固定的字面量，或者是编译器能算出的计算（数组大小、缓冲区长度、switch 标签、模板实参），就用 constexpr。如果值要到运行时才确定，但之后不应再改变，就用普通的 const，比如函数参数的一个 const 副本。

从 C++20 开始还有 consteval，用于那些必须在编译期运行的函数：

consteval int square(int x) { return x * x; }
constexpr int area = square(8); // computed during compilation

constexpr 函数可以在编译期运行；consteval 函数则总是必须在编译期运行，否则就是错误。

指针与 const：从右往左读

这是 const 最容易让人犯迷糊的地方，因为这个关键字可以写在 * 的任意一边，而两种写法的含义正好相反。诀窍是从右往左读声明。

#include <iostream>
using namespace std;

int main() {
    int x = 1, y = 2;

    const int* p1 = &x;   // pointer to const int: can repoint, can't edit *p1
    p1 = &y;              // OK
    // *p1 = 5;           // error: *p1 is const

    int* const p2 = &x;   // const pointer to int: can edit *p2, can't repoint
    *p2 = 99;             // OK
    // p2 = &y;           // error: p2 is const

    const int* const p3 = &x; // const pointer to const int: neither allowed

    cout << *p1 << " " << *p2 << " " << *p3 << "\n";
    return 0;
}

从右往左读 int* const p2：“p2 是一个指向 int 的 const 指针”。把 const int* p1 读作“p1 是一个指向 const int 的指针”。如果搞错了，你会花不少时间对着一条错误发愣：它说你不能修改一个你以为可以修改的东西。

一个实际的坑：永远不要取一个 const 的地址，再把 const 转换掉去修改底层对象。如果原对象本来就是 const，这样做就是未定义行为，编译器可以假定这个值永远不会改变，你的“写入”可能直接被忽略。

用 const 引用作函数参数

const 在日常中最常见的用法，是按引用传递大对象而不复制它们。const& 参数既避免了复制，又保证函数不会修改调用者传进来的实参。

#include <iostream>
#include <string>
using namespace std;

// No copy of the string is made, and we can't accidentally mutate it.
void greet(const string& name) {
    // name += "!"; // error: name is const
    cout << "Hello, " << name << "!\n";
}

int main() {
    string user = "Ada";
    greet(user);
    greet("Grace"); // const& also binds to a temporary literal
    return 0;
}

对于任何超过几个字节的参数（字符串、vector、你自己写的类），按 const& 传递都是默认的选择。注意它还能让函数接受像 "Grace" 这样的临时值：普通的非 const 引用不能绑定到临时值，所以如果这里去掉 const，第二次调用就会被拒绝。

const 成员函数

写类的时候，凡是不修改对象的方法，都在末尾加上 const。正是这一点让该方法可以在 const 实例和 const& 参数上调用。没有它，你就没法通过 const 句柄读取自己的对象。

#include <iostream>
#include <string>
using namespace std;

class Account {
    double balance = 0;
public:
    void deposit(double amount) { balance += amount; } // modifies -> not const
    double getBalance() const { return balance; }       // read-only -> const
};

int main() {
    Account a;
    a.deposit(50);

    const Account& ref = a;        // a read-only view
    cout << ref.getBalance() << "\n"; // works only because getBalance() is const
    // ref.deposit(10);            // error: deposit() is not const
    return 0;
}

把只读方法标记为 const 的这种做法叫作 const 正确性（const correctness）。尽早养成这个习惯：给一个本该是 const 的方法补上 const 很容易，但等代码库变大之后再到处补 const 就很痛苦了，因为每个通过 const 引用调用它的地方都依赖于它。

下一步：运算符

现在你的值已经可以用 const 锁定了，下一步就是用它们做事情。运算符这一页讲解算术、比较、逻辑和赋值运算符，包括整数除法和运算符优先级中的坑，以及 const 与那些你不能使用的赋值运算符之间的关系。