1. 从一桩“陈年bug”说起:const 到底在保护什么
先讲个我早年间遇到的事。当时维护一个图像处理的模块,有位同事写了一个函数,作用是把图像像素的亮度值整体调高。函数签名大概是这样的:
cpp复制void brighten(int* pixel, int width, int height, int delta);
结果上线后,诡异的事情出现了:某些图像处理完之后,不仅亮度变了,连通道顺序都乱了。查了两天,最后发现是有个调用方在调试功能时,直接在函数内部把 pixel 指针做了偏移和修改,又把 width 和 height 的局部拷贝给改了,导致调用方后续的 ROI(感兴趣区域)计算全部错位。
根子在哪?问题不在逻辑,而在那个函数签名上—— int* pixel 把指针的全部权限都交给了被调函数。指针本身靠值传递没错,但它指向的那块内存,被调函数默认拥有完全读写权。这就引出了本文真正想讲透的问题:const 不是“把变量变常量”这么简单,它本质上是你在代码里主动声明的一组“权限边界”。
很多 C/C++ 初学者学 const 时,第一反应是背规则:const int* p 是指向常量的指针,int* const p 是常量指针;const int& ref 是常量引用……背完之后一写代码还是蒙。因为规则背后的“为什么”没人讲透。你不理解 const 的权限语义,就永远只能靠记忆硬扛,而 C/C++ 里的指针和引用组合形态恰恰又是重灾区,尤其是:
const int* p和int const* p到底是不是一回事?int* const p能不能指向普通变量?const int& ref = 42;这行代码为什么合法?- 为什么有的函数参数写
const T&,有的写T* const,有的写const T*?
这一个个问题单独拎出来都能背,一旦组合在一起,比如写成 const int* const p 或者 T const* const&,很多人就懵了。这篇文章我会把 const 与指针、引用从底层权限模型的角度重新拆一遍,不靠死记,而是给你一套能推演所有组合的思维方法。
顺带说一句,网络热词里经常出现“c/c++ 八股”,const 与指针/引用确实是八股题的重灾区,面试官最爱在这里挖坑。但八股只是表象,真正理解权限语义后,这类题就是送分题。下面我们直接进入正题。先说结论:const 修饰的是“通过这个变量名,能不能改这块内存”,跟“这块内存本身是不是只读”是两回事。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. const 的权限本质:一个变量名就是一块内存的“门禁卡”
2.1 变量名、内存与访问权限的三层关系
要彻底搞懂 const,必须先建立一个三层模型:
- 内存实体:物理上存在的一块区域,它是客观的,没有“只读”或“可写”这一说——硬件层面只有地址和数据;
- 变量名:编译器为程序员提供的访问内存的“门禁卡”,也叫“名称绑定”;
- 访问权限:编译器根据变量声明时给出的限定符(比如 const),决定这张门禁卡允许执行哪些操作。
举个例子:
cpp复制int a = 10;
const int b = 20;
内存里存在两个区域,分别存着 10 和 20。理论上,硬件并没有阻止你往 b 所在内存写数据——事实上,b 通常也是放在可写的数据段或栈上的。真正阻止你修改它的是编译器:因为它知道 b 的“门禁卡”等级是 const int,所以当你写 b = 30 时,编译器直接报错:assignment of read-only variable 'b'。
所以,const 并不是“把内存变成只读”,而是编译器对你这块内存的访问行为施加约束。这就是为什么 const_cast 可以“剥掉”常量性——因为它只是在编译层面换了一张“门禁卡”,并没有改变内存本身的物理属性。
再进一步,指针和引用这层“门禁卡”的等级,由两个维度决定:
- 第一步:指针/引用本身能不能改变指向(顶层 const,即 top-level const);
- 第二步:通过指针/引用能对目标内存做哪些操作(底层 const,即 low-level const)。
这两个维度必须分开记,因为它们的语法位置和语义完全不同。很多人混淆 const int* 和 int* const,本质上就是没有区分这两个维度。
2.2 顶层 const 与底层 const:帮你秒懂一切指针组合
顶层 const(top-level const)指的是:指针/引用这个对象本身是常量,不能改变它自己保存的地址/绑定关系。
底层 const(low-level const)指的是:通过这个指针/引用去访问目标内存时,不能修改目标的值。
只看定义比较抽象,结合代码:
cpp复制int x = 1;
int y = 2;
const int* p1 = &x; // 底层const:p1可以改指向,但不能通过p1改x
// p1 = &y; // OK,指针本身可以改指向
// *p1 = 100; // 错误:表达式必须是可修改的左值
int* const p2 = &x; // 顶层const:p2不能改指向,但可以通过p2改x
// p2 = &y; // 错误:p2是只读变量
*p2 = 100; // OK,x变成了100
const int* const p3 = &x; // 底层const + 顶层const
// p3 = &y; // 错误
// *p3 = 100; // 错误
p3 这种“既不能改指向,也不能通过它改目标”的组合,看着最吓人,其实拆开就是两个独立的 const,直接叠加就行。
那么如何快速判断一个声明是顶层还是底层?这里有一个实操技巧:用“从右往左读”的方法,同时注意 const 修饰的是谁。
const int* p:const 修饰int,说明*p是 const,也就是“通过 p 访问到的 int 是 const”——底层 const;int const* p:纯语法糖,和上面完全等价。const 修饰的还是int;int* const p:const 修饰*p整体,也就是“指针变量 p 本身是 const”——顶层 const。
提示:
const int*和int const*只是书写顺序不同,完全等价。很多人在这上面浪费时间纠结,其实只要记住“const 修饰它左边最近的那个类型/复合类型”这个规则,通通能解决。唯一例外是const出现在开头时,它修饰的是右边的整个类型。
我见过的最实用的记忆法,是把 * 想象成“打开门禁的钥匙”:
const int* p:这把钥匙打开门后,里面是只读的(你进得去,但动不了东西);int* const p:这把钥匙本身被锁死了(你只有这把钥匙,换不了别的门),但门里面的东西随意动;const int* const p:钥匙锁死了,门里的东西也是只读的——你只能隔着玻璃看一眼。
指针本身是对象,所以指针本身可以被 const 修饰(顶层 const);指针指向的目标也可以是 const(底层 const)。这两者完全独立,可以组合成四种形态。这是整个 const 语义的基石,下面引用也是按同一套逻辑展开的。
3. 引用与 const 的纠缠:为什么 const int& 能绑定临时量
3.1 引用不是指针,但权限模型一致
引用(reference)在语法层面是“别名”——它没有独立的内存空间,绑定到一个对象上之后,终身不能换绑。这个“终身不变”的特性,决定了引用天然自带“顶层 const”属性。你可能没听过这个说法,但你可以想一个问题:int& ref = x; 之后,你能让 ref 改绑到 y 吗?不行,语法上根本不允许。也就是说,普通引用本身已经隐含了顶层 const 的语义。
所以我们讨论引用时,真正需要关心的只有“底层 const”——也就是通过这个引用能不能修改目标内存。于是只有两种形态:
int& ref:底层非 const,通过 ref 可以修改目标;const int& cref:底层 const,通过 cref 不能修改目标。
这就是为什么 int& ref = 42; 是编译错误,而 const int& cref = 42; 是合法的。因为 42 是一个右值(临时量),它没有持久的名字,如果你持有一个非 const 的引用,就相当于给临时量发了一张“可修改门禁卡”——不仅没有实际意义,还会引发语义混乱。而 const 引用等于给这个临时量续了命,同时承诺不修改它。
这里必须强调一个关键点:const 引用可以延长临时对象的生命周期。这是 C++ 里一个极其重要的规则。当 const int& cref = 42; 执行时,编译器会为 42 分配一块临时内存,并将 cref 绑定到它,同时把这块临时内存的生命周期延长到 cref 的生命周期结束为止。这意味着你可以写出这样的代码:
cpp复制const std::string& name = std::string("hello") + " world";
// name 依然合法,临时 std::string 的生命周期被延长了
这个规则在实际工程中大量使用,比如函数返回一个较大的临时对象时,用 const 引用接住,可以避免一次不必要的拷贝。但如果你写 std::string& name = std::string("hello") + " world";,编译器会直接报错——因为临时量不能绑定到非 const 左值引用上。
