C/C++ const：那些年我们一起追过的“常量”，原来有这么多秘密
目录
在编写代码时，我们经常需要保证某些数据不被意外修改，C++ 提供了 const 关键字来实现这一目的。
不要小看 const，它在C++ 中非常重要，变量、指针、函数参数、函数返回值、成员函数等地方都有它的身影。
今天就让我们一步一个脚印的来看看const 的这些用法。
修饰变量
const名叫常量限定符，用来限定特定变量，以通知编译器该变量是不可修改的。
修饰常量及数组
const int maxUsers = 100; // maxUsers 从此恒定 100 const int arr[] = { 1,2,3 }; const定义时必须初始化（除非用 extern 声明），而一旦初始化，其值在生命周期内不可修改。
与宏常量的比较
与C语言不同，C++中的const变量（尤其是全局const）通常不会分配内存，而是直接嵌入到指令中（类似#define）。
宏常量是用 #define 在预处理阶段定义的：
#define MAX_USERS 100 它只是单纯的文本替换，在预处理阶段就把代码里的 MAX_USERS 全部替换成 100。
编译器根本不知道有个叫 MAX_USERS 的东西。
从定义点开始，到文件结束（除非 #undef），它会污染所有后续代码，不管你在不在命名空间里。
想象一下你要写一个计算圆面积的函数，用 const 和宏分别定义圆周率：
// const 版本 const double PI = 3.14159; double area(double r) { return PI * r * r; } // 宏版本 #define PI 3.14159 double area(double r) { return PI * r * r; } 看起来差不多，但坑往往藏在细节里。假如你在另一个文件里不小心写了个变量叫 PI：
int PI = 42; // 合法，PI 只是一个普通变量名 用 const 版本：完全没问题，PI 作为常量有自己的作用域，不会和这个变量冲突。
用宏版本：编译错误！因为 #define PI 是全局的，编译器会把 int PI = 42; 里的 PI 也替换成 3.14159，变成 int 3.14159 = 42;，显然不合法。
这就是宏的“名称污染”问题。
因此定义常量时，首选 const。
宏的唯一用武之地是那些必须发生在预处理阶段的事情，比如条件编译（#ifdef）、头文件保护、以及一些需要字符串化或拼接的技巧。
所以放下对宏的执念吧，拥抱 const，让代码更安全、更可维护！
const 与指针
又到了C++ 里最让人头疼的组合—— const 与指针。
这俩凑一块儿，就像两个性格迥异的室友：一个总想改变（指针），一个坚决不变（const）。
当它们在一起后，就会出现三种组合：
- 指向常量的指针（pointer to const）
- 常量指针（const pointer）
- 指向常量的常量指针（const pointer to const）
别晕，让咱们一个一个拆解它们。
指向常量的指针
有句话叫：指针可以变，但指向的值不能动。
const int* p; // 或者 int const* p（两种写法等价） p 是一个指针，它指向一个 const int。
你可以改变 p 本身，让它指向别处；但你不能通过 p 来修改它当前指向的那个整数。
就像你拿着一张“禁止涂改”的便签，你可以把便签贴到不同的墙上，但无论贴哪，墙上的字都不能改。
int a = 10, b = 20; const int* p = &a; // p 指向 a *p = 30; // 错误！不能通过 p 修改 a p = &b; // 可以，p 现在指向 b 可以记住，const 在 * 的左边，但不能改变指向的值。
常量指针
指针本身不能动，但指向的值可以改。
int* const p = &a; // p 是一个常量指针，必须初始化 p 是一个常量指针，也就是说指针本身是只读的。
一旦它指向某个变量，就不能再指向别处。
但是，你可以通过它修改它指向的那个变量（只要变量本身不是 const）。
int a = 10, b = 20; int* const p = &a; // p 永远指向 a *p = 30; // 可以，a 现在是 30 p = &b; // 错误！不能修改 p 本身 记住const 在 * 的右边，不能改变指针。
指向常量的常量指针
指针和指向的值都不能动。
const int* const p = &a; 合体版！p 本身是常量，指向的也是常量。
所以既不能改 p 的指向，也不能通过 p 修改指向的值。
int a = 10, b = 20; const int* const p = &a; // p 永远指向 a，且不能通过 p 改 a *p = 30; // 错误！ p = &b; // 错误！ 三种指针总结
| 类型 | 声明形式 | 指针本身可改？ | 指向的值可改？ |
|---|---|---|---|
| 指向常量的指针 | const int* / int const* | 可改 | 不可改 |
| 常量指针 | int* const | 不可改 | 可改 |
| 指向常量的常量指针 | const int* const / int const* const | 不可改 | 不可改 |
const 与函数参数
const 与函数参数——就像给函数的输入加一道“安检门”，不同的参数传递方式对应不同的安检级别。
值传递
void func(const int x) { // x 是只读的，不能修改 } 参数 x 是通过值传递的，函数内操作的是实参的副本。
加上 const 意味着这个副本在函数内是只读的。
在函数内部，你不能修改 x。但这对外面的实参没有任何影响——因为本来就是副本。
其实对于值传递，加不加 const 对外部调用者来说没有区别（反正都是副本）。
它的作用主要是对内：告诉函数的读者（以及编译器）这个参数在函数内不应该被修改，起到自我约束的作用，避免不小心改错。
不过，因为值传递本身就会拷贝，如果对象很大，拷贝开销会很高，所以通常只适用于基本类型或小型对象。
指针传递
指针传递时，const 可以修饰指针本身，也可以修饰指针指向的数据，这就回到了我们之前讨论的“指向常量的指针”和“常量指针”。
在函数参数中，它们分别扮演不同角色：
- 指向常量的指针：保护数据不被改
void func(const int* p) { // 不能通过 p 修改 *p，但可以修改 p 本身（比如让 p 指向别处） } 假如你想通过指针传入一个大型数组或对象，并且承诺不会修改它。
这样调用者可以放心地把数据交给你，即使数据本身是 const 的也能传进来。
这么做避免了拷贝，同时保证了数据只读。
- 常量指针：保护指针本身不改
void func(int* const p) { // 不能修改 p 本身（比如让 p 指向别处），但可以通过 p 修改 *p } 你希望这个指针在函数内始终指向同一个对象（比如用于遍历时固定起点）。
但这种情况很少单独使用，因为通常我们更关心数据是否被修改，而不是指针本身是否变。
- 指向常量的常量指针：双重保护
void func(const int* const p) { // 既不能改 p，也不能通过 p 改 *p } 你想表达“我不仅不修改数据，也不会改变指向”。
不过这种写法有点过度约束，通常用常引用（见下文）更简洁。
引用传递
void func(const MyClass& obj) { // obj 是常引用，不能通过它修改对象 } obj 是传入对象的别名，加上 const 表示这个别名是只读的。
优势：
- 避免拷贝：对于大型对象（如 std::string、vector），直接传值会拷贝整个对象，开销巨大。传引用则没有拷贝。
- 保护数据：const 保证了函数内不会修改传入的对象。
- 接受临时对象：常引用可以绑定到临时对象（右值），比如 func(getString()) 是合法的，而普通引用不行。
这就像你进图书馆看书，图书馆给你一张“只读阅览证”——你可以随便看（引用），但不能在书上写写画画（const），而且这张证不占用你书包空间（无拷贝）。甚至你临时路过图书馆（临时对象），也能拿这张证进去翻翻。
三种传递方式总结
| 传递方式 | 语法 | 适用场景 | 优势 |
|---|---|---|---|
| 值传递 | void f(const int x) | 基本类型小数据 | 调用者无需担心数据被修改 |
| 指针传递 | void f(const int* p) | 只读大数组/对象，允许空 | 避免拷贝，保护指向内容 |
| 引用传递 | void f(const T& ref) | 大对象只读，首选方式 | 避免拷贝和指针语法，保护对象 |
const 与函数返回值
这是 const 在函数出口设置的“关卡”，告诉调用者：“给你这个返回值，但有些事你不能做！”
不同的返回方式配上 const，效果天差地别，我们逐一拆解。
返回 const 值
const int getAge() { return 10; } 函数返回的是一个 const 限定的对象（通常是副本）。
不过对基本类型而言，返回const值意义不大，因为右值本来就不能被修改。
但对类类型可防止意外赋值：
const std::string getName() const; // 返回 const 对象 比如 getName().append("suffix") 会被编译器阻止，因为 append 是非 const 成员函数。
这在某些场景下能避免无意义的修改（毕竟临时对象马上就销毁了）。
返回 const 指针
const int* getData() { return 10; } // 返回 const int*，指向的数据只读 返回一个指针，指向的数据是 const 的。
调用者不能通过这个指针修改指向的数据，但可以修改指针本身（比如让指针指向别处）。
返回 const 引用
const std::string& getName() { return "xingxing"; } // 返回 const 引用 返回一个 const 左值引用，指向某个对象。调用者可以通过这个引用读取对象，但不能修改它。
就像你家墙上开了一扇玻璃窗，你可以透过窗户看到屋里的东西（读取数据），但你不能伸手进去改（不能修改）。窗户本身是固定的（引用不能改指向），而且不占你地方（无拷贝）。
类中的 const
好了，这次我们走进类的内部，看看 const 在类中担任哪些角色。
这里涉及四个角色：const 成员函数、mutable 关键字、const 对象、const 静态成员。
它们各有各的规矩，我们一个个介绍。
const 成员函数
在类的成员函数后面加 const，就是向编译器和调用者承诺：“这个函数不会修改对象的状态（非静态成员变量）。”
class Student { public: Student(std::string name = nullptr) :_name(name), _age(10) {} std::string getName() const { return name; } void setName(const std::string& n) { name = n; } int getAge() { return _age; } private: std::string name; int _age; }; 我们在getName()成员函数后面加上 const，如果在getName里面调用非const成员函数：
std::string getName() const { int a = getAge(); // 报错，类型不兼容 return _name; } 编译器就会报错，同样的，调用非const成员变量也会报错。
因为const向编译器和调用者承诺了不会修改对象状态。
const 对象
假设你有一个 const 对象（比如 const Student s;），它只能调用 const 成员函数。
如果 getName 没加 const，s.getName() 就会编译错误。
当你创建对象时加上 const：
const Student alice("Alice"); alice.getName(); // 可以，因为 getName 是 const alice.setName("Bob"); // 错误！不能调用非 const 成员函数 这个对象从创建到销毁，如果不是 mutable 成员变量都不可改变。它只能调用 const 成员函数。
此方法常用于表示不可变的数据实体，比如配置文件、常量配置等。
mutable 关键字
我们了解了const 成员函数之后可以知道，在类的成员函数后面加 const后就不能修改其对象。
但生活总有意外——有时候在逻辑上不应该修改对象，可技术上却不得不改一些“内部状态”。比如：
你有一个互斥锁，需要在 const 成员函数里加锁解锁，这当然会修改锁的状态，但逻辑上并不影响对象的数据。
这时候 const 的严格性就成了障碍。那么我们就可以用 mutable 给 const 开个“后门”。
class ThreadSafeCounter { public: int get() const { std::lock_guard<std::mutex> lock(m); // m 被修改（加锁） return value; } private: mutable std::mutex m; int value = 0; }; 这里的 m 是 mutable 的，因为加锁操作改变了它的状态，但这并不影响 value 的读取。逻辑上 get() 仍是只读操作。
const 静态成员
最常见的组合是 const static 成员（顺序无所谓，static const 和 const static 等价）。
这表示一个属于类的常量，所有对象都能访问，且不能修改。
class MathConstants { public: static const double PI; // 声明 static const int MAX = 100; // 整型常量可以在类内初始化 }; // 类外定义（如果不在类内初始化） const double MathConstants::PI = 3.14159; 我们可以看到整型（或枚举类型）的 const 静态成员可以在类内直接初始化，但是非整形的还需在类外定义。
不过在C++17 后 引入了inline static，就不存在以上问题了。
class MathConstants { public: inline static const double PI = 3.14159; }; const 与 constexpr
通过以上内容我们知道const它的核心是“承诺不变”。
你可以用它修饰变量，告诉编译器：“这个值我不会改，你别让我改它。”
但这个值到底是在编译时确定还是运行时确定，const 并不关心。
而constexpr是C++11引入的，它的核心是“编译时可知”。
它强制要求在编译期就能算出值（或至少在编译期可求值）。
变量初始化的时机不同
const int a = 42; // 可以，编译期常量 const int b = rand(); // 也可以，运行时初始化，之后不能改 constexpr int c = 42; // 可以，编译期常量 constexpr int d = rand(); // 错误！rand() 不是常量表达式 - const 变量：可以在运行时初始化，之后不能修改。
- constexpr 变量：必须在编译期初始化，且初始化表达式必须是常量表达式（即编译期可求值）。
constexpr 变量本身也是 const 的，所以 constexpr int x = 42; 等价于 const int x = 42;，但反之不成立。
函数是否可以在编译期调用
const 成员函数：如前问所述，承诺不修改对象状态，与编译期求值无关。
constexpr 函数：如果传入的参数是常量表达式，那么该函数可以在编译期求值；如果传入运行时的值，它也可以像普通函数一样在运行时调用。
constexpr int square(int x) { return x * x; } int arr[square(5)]; // 编译期求值，数组大小合法 int y = 10; int z = square(y); // 运行时调用，也可以 修饰指针的含义不同
int x = 10; const int* p1 = &x; // 指向常量的指针，可改指向，不可改值 int* const p2 = &x; // 常量指针，不可改指向，可改值 constexpr int* p3 = &x; // ? const 指针：我们之前讨论过，规则灵活。
constexpr 指针：C++11 起，constexpr 指针必须初始化为 nullptr、0，或者静态存储期对象的地址（如全局变量、静态变量），因为它们的地址在编译期是已知的。
局部变量的地址在运行时才确定，不能用于初始化 constexpr 指针。
static int slocal = 42; constexpr int* p = &slocal; // 可以 int local = 10; constexpr int* q = &local; // 不可以！local 地址不是编译期常量 constexpr 指针本身是常量指针（即不能改指向），而且指向的地址必须在编译期确定：
constexpr int* p = &global; *p = 100; // 可以，global 变为 100 如果希望指向的值也不能改，可以结合 const：
const constexpr int* p = &slocal; *p = 100; // 不可以 总结
在 C++ 中，const 关键字用于声明一个不可修改的实体，它在编译时提供语义约束并由编译器强制执行。
const 可以修饰基本类型变量、指针、引用（常引用）、函数参数（值传递、指针传递、引用传递）以及函数返回值。
在类中，const 成员函数承诺不修改非 mutable 成员变量，使 const 对象能够调用这些函数。
mutable 成员则允许在 const 成员函数中修改不影响对象逻辑状态的内部数据。
static const 成员定义类级别的常量。
而 constexpr（C++11 起）进一步要求编译期求值，可用于变量、函数和构造函数，实现真正的编译时常量，与 const 互补。
正确使用 const 能提升代码的安全性、可读性，并辅助编译器优化。
