第8章 引用与const限定

指针给了你直接操作内存地址的能力，但随之而来的是空指针、野指针和复杂的语法。有没有一种方式，既能像指针一样高效地“指向”某个对象，又更安全、更直观？这就是引用（Reference）的用武之地。而const，则是你代码中的“安全锁”，它能明确告诉编译器和你自己：哪些数据是只读的，不能被修改。

8.1.1 引用的声明与使用

声明引用时，使用&符号，并且必须在声明时进行初始化，绑定到一个已存在的对象。一旦绑定，终身不变。

int value = 10;
int& ref = value; // ref是value的引用，即别名

ref = 20; // 通过引用修改值
cout << value; // 输出 20，原变量也被修改
cout << &value << " " << &ref; // 输出相同的地址

8.1.2 引用 vs 指针：一张表看清本质

理解了引用的基础，我们立刻把它和上一章学的指针放在一起对比。这是C++面试的经典问题，也是实际开发中选择的依据。

我在项目中踩过这个坑：早期为了“灵活”，大量使用指针作为函数参数，结果团队里新手经常忘记检查空指针，导致程序崩溃。后来我们制定规范：如果函数参数目的只是读取或修改传入的对象，且不允许为空，优先使用引用。这从语法层面就杜绝了空值问题。

8.2 const限定符：定义“只读”规则

const关键字用于定义一个值不可被修改的对象。它就像给你的变量贴上一个“只读”标签，编译器会帮你检查任何试图修改它的操作。

const int MAX_SIZE = 1024; // 定义一个常量
// MAX_SIZE = 2048; // 错误！不能修改const变量

const double PI = 3.1415926;
int radius = 5;
double area = PI * radius * radius; // 正确，只是读取

实际开发中，我推荐用const替换C语言风格的#define宏定义常量。因为const变量有明确的类型，会参与类型检查，并且会进入符号表，调试时可以看到它的值。而宏只是简单的文本替换。

8.2.1 const与指针的组合：四种情况

当const遇到指针，位置不同，含义天差地别。这是C++语法的一个难点，但只要你记住“const修饰它左边的东西，如果左边没东西，就修饰右边的东西”这个口诀，就能轻松破解。

我们用具体代码来验证：

int a = 10, b = 20;

// 情况1：指向常量的指针（指针可以变，指向的值不能变）
const int* p1 = &a;
// *p1 = 30; // 错误！不能通过p1修改a的值
p1 = &b; // 正确，可以让p1指向b

// 情况2：常量指针（指针不能变，指向的值可以变）
int* const p2 = &a;
*p2 = 30; // 正确，a现在等于30
// p2 = &b; // 错误！p2不能再指向别的地址

// 情况3：指向常量的常量指针（都不能变）
const int* const p3 = &a;
// *p3 = 40; // 错误！
// p3 = &b; // 错误！

8.3 引用与const的强强联合

引用本身不能重绑定，但如果加上const，我们主要约束的是不能通过这个引用来修改目标对象。这产生了两种主要用途：常量引用和函数参数传递。

8.3.1 常量引用

声明为const T&的引用，不能用来修改它绑定的对象。但它可以绑定到常量、非常量，甚至临时对象（右值）。

int x = 100;
const int& cref1 = x; // 正确，绑定到非常量
// cref1 = 200; // 错误！不能通过常量引用修改

const int y = 200;
const int& cref2 = y; // 正确，绑定到常量

// 绑定到临时对象（右值）
const int& cref3 = 300; // 正确！字面量300是临时对象
// int& bad_ref = 300; // 错误！非常量引用不能绑定右值

这里有个隐藏的坑：常量引用绑定临时对象时，会延长该临时对象的生命周期，使其生命周期与引用相同。这是C++语言的特殊规则，非常有用。

8.3.2 函数参数中的常量引用

这是const引用最实用、最高频的场景。当函数只需要读取参数值，而不需要修改它时，使用常量引用作为参数。

// 不好的设计：传值，大对象会有拷贝开销
void printStudentBad(Student stu) {
    cout << stu.name << ", " << stu.age;
}

// 好的设计：传常量引用，零拷贝，且安全
void printStudentGood(const Student& stu) {
    // stu.age = 25; // 错误！编译器阻止你意外修改
    cout << stu.name << ", " << stu.age;
}

// 调用
Student s {"Alice", 20};
printStudentGood(s); // 传递对象本身，没有拷贝
printStudentGood(Student{"Bob", 22}); // 甚至可以传递临时对象！

我在项目中强制要求：所有自定义类型（结构体、类）作为函数参数时，如果不需修改，必须使用const T&。对于内置类型（int, double等），由于拷贝开销极小，传值或传引用均可，但为了代码一致性，也推荐使用const T&。

8.4 函数返回引用

函数可以返回引用，但必须确保返回的引用绑定的是一个在函数返回后依然有效的对象。最常见的是返回参数引用、类成员引用，或者全局/静态变量引用。

// 正确：返回参数引用
int& getLarger(int& a, int& b) {
    return (a > b) ? a : b;
}

// 使用
int x = 5, y = 10;
getLarger(x, y) = 100; // 现在y等于100
cout << y; // 输出100

// 错误：返回局部变量的引用（悬空引用）
int& badFunction() {
    int local = 42;
    return local; // 警告！local在函数结束时销毁
} // 返回的引用指向已销毁的内存，行为未定义

如果你看到编译器警告“returning reference to local variable”，100%是犯了上面的错误。实际开发中，返回引用常用于实现链式调用，比如cout << a << b;中的<<运算符就返回流对象的引用。

int a = 1, b = 2;
const int* ptr1 = &a;
int* const ptr2 = &a;
const int* const ptr3 = &a;