propsX做了这么多年C语言，经常在面试题和期末考试里看到指针常量和常量指针这道题，也见过太多人在这个点上栽跟头。说实话，我自己刚学那会儿也绕得晕头转向，明明就是“const”和“*”几个字符的位置关系，却总在关键时候掉链子。后来在一次嵌入式项目里因为把一个const int *误当成了int *用，导致编译告警被忽视，程序跑飞查了半天，才真正把这两个概念刻进脑子里。
这篇文章就把指针常量和常量指针这件事彻底讲清楚。我会从语法定义、底层内存模型、快速判别技巧、实际应用场景几个角度展开，末尾附带一组高频笔试题剖析。无论你是刚学指针的初学者，还是复习备考、准备面试的进阶者，或者单纯想把这块基础补牢，看完应该都能做到十秒内准确判断任意指针声明的含义。
1. 两个名字为什么这么容易搞混：根源在中文翻译和阅读习惯
先别急着背结论。理解这对概念之前，我们得先搞清楚“为什么它们这么容易混”。因为这个问题的答案，恰恰就是解决问题的关键。
1.1 中文术语的字序陷阱
中文翻译给我们的记忆带来了很大的干扰。“指针常量”四个字，字面理解是“指针”这个“常量”，也就是指针本身是个常量——这其实对应的是int *const p。“常量指针”四个字，字面理解是“指向常量的指针”，也就是指针指向的数据是常量——这对应的是const int *p。
问题在于，中文倾向于把修饰语放在名词前面。“常量指针”按中文语感来读，很容易被理解成“一个指针，它是常量的”——但实际上它指的是“指向常量的指针”。而“指针常量”反而读起来像“一个常量，类型是指针”——这倒是和它的真实含义一致。
所以靠字面意思去记忆，会出现一次完全反向的错位。这也是为什么很多老程序员建议直接用英文术语“const pointer”（指针常量）和“pointer to const”（常量指针/指向常量的指针）去区分，英文的语序更准确，“pointer to const”很直白地告诉你“这是一个指针，指向const数据”，而“const pointer”则告诉你“这是一个const的指针”。
1.2 真正的根因：const修饰对象的错位
问题的本质不在中文本身，而在于很多人读声明时用错了方法。C语言声明遵循“从内向外、从右向左”的阅读法则，但大多数人习惯从左往右读，于是const int *p被读成“const int的指针p”，这本身没错，但“const int”和“const pointer”在脑子里搅在一起后，就容易把const看成修饰p而不是修饰*p。
这里的核心知识点是：const在声明中修饰的永远是其左侧紧邻的类型或变量。当const出现在*的左边时，const修饰的是指针指向的内容；当const出现在*的右边时，修饰的是指针变量本身。
来看一组对照：
c复制const int *p; // 等同于 int const *p; 指向const整型的指针，指针本身可变
int *const p; // 指向整型的const指针，指针本身不可变
const int *const p; // 指向const整型的const指针，两者都不可变
我见过太多人把第一行记成“常量指针”，然后告诉我“p指向的那个数不能通过p修改”，这没错；但紧接着被问“p本身能变吗”就答不上来了。所以关键不是记住名称，而是学会读声明，从声明本身推导出所有性质。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 底层内存模型：从地址和权限的角度理解这两种类型
有人会觉得背结论就够了：“指针常量就是带const的指针，常量指针就是指向常量的指针。”但如果不理解底层，一旦遇到复杂声明、函数参数传递、结构体嵌套指针、多级指针场景，背结论一定会翻车。这节我们从内存角度把两个概念彻底拆开。
2.1 指针变量也是一个变量，它有自己的地址
在32位系统上，指针变量占用4字节，64位系统上占用8字节。无论它指向什么类型，指针变量本身都存放在栈区或静态区，拥有自己的内存地址。所以当我们说“指针本身是不是常量”时，问的是“这个存放地址的变量，是否允许被写入新的地址值”。
考虑下面这段代码：
c复制int a = 10, b = 20;
int *const cp = &a; // cp 是一个指针常量，它不能改指向
const int *pc = &a; // pc 是一个常量指针，它指向的值不能通过pc改
cp = &b; // 编译错误：cp是常量，不能赋值
pc = &b; // 编译通过：pc本身不是常量，可以指向别处
*pc = 30; // 编译错误：pc指向const整型，不能通过pc改值
底层发生了什么？cp和pc都存放在栈上某个地址，它们的内容（内存单元里存的数）都是a的地址。访问*cp或*pc时，CPU先读出指针变量里的地址，再访问该地址对应的内存。区别在于，编译器在处理cp = &b这条语句时，因为cp声明为int *const，发现cp是只读变量，直接报错；而pc = &b完全合法。同理，*pc = 30在语义上等于解引用后写入，写入的目标被const限制为只读，所以编译不过。
2.2 权限模型：什么可读，什么可写
把指针想象成一张门禁卡，有两层权限，第一层是“卡本身能不能换发”，第二层是“卡片能打开的门能不能改动内部布局”。
const int *p：门禁卡可以随便换（p可以指向别处），但它能打开的所有门都只允许参观，不允许改动（*p是只读）。int *const p：门禁卡被固定死了（p不能再指向别处），但卡片能打开的那扇门，进去之后可以随意折腾（*p可读可写）。const int *const p：卡也固定死，门也锁死，只能读不能改。int *p：卡随意换，门随便改。
这个权限模型结合一个铁一般的规则——const限定的是“通过该指针”的访问权限，不代表目标对象真的不可变。意思是，如果a本身不是const int，你完全可以通过另一个指针修改它：
c复制int a = 10;
const int *p = &a; // p限制了通过p修改a
a = 42; // 合法：a本身不是常量
*p = 43; // 编译错误：不能通过p修改
这个例子特别重要，它在实际项目中经常出现，比如你想给某个函数传入只读视角，但调用者仍然保留写权限。
2.3 多级指针和const的组合：什么时候会被绕晕
很多人以为掌握了上面三个组合就万事大吉，直到遇到const int **pp、int *const *pp、int **const pp这类多级声明，才意识到自己的理解还停留在表面。其实方法一样：从右往左读，const修饰它左边最近的那个符号（变量或解引用层）。
c复制const int **pp; // 指向“指向const整型的指针”的指针
int *const *pp; // 指向“指向整型的const指针”的指针
int **const pp; // 指向“指向整型的指针”的const指针
读法口诀：先找到最右边的标识符，然后一步步向左。int *const *pp读作“pp是指针，指向一个const指针，该const指针指向int”。所以*pp是只读的（不能给它赋值），**pp可以通过**pp = xxx修改，因为最底层的int没有被const限定。
这里容易出的一个编译错误是：把const int **赋给int **。下面的代码是错的：
c复制const int a = 5;
const int *p = &a;
const int **pp = &p; // 正确
int **q = &p; // 编译错误！不能将 const int ** 转换为 int **
为什么？如果int **q = &p合法，那么*q是int *，而*q实际指向p（类型是const int *），于是可以通过**q = 10修改一个const int，这直接破坏了const的完整性约定。编译器的规则极其严格，就是为了防止你绕过只读权限。理解到这一层，多级指针场景基本就不会再犯错了。
3. 十秒判别法：看到任意指针声明立刻判断归属
很多攻略会告诉你“看const在前还是后，在前就是指向常量的指针，在后就是指针本身是常量”。这个说法大方向没错，但不够严谨，因为它没处理int const *p这个优雅的等价写法，也没处理多级指针。我这里给你一套更保险、任何场景都能用的判别流程。
3.1 三步判别流程
看到任何指针声明，按下面三个步骤走：
第一步，找到最右边的标识符，确定它是什么。标识符是变量名，它前面最近的*个数决定了它是指针还是指向指针的指针。
第二步，找到声明中的所有const。每个const修饰它左侧最近的类型关键字或*。如果const在类型关键字（如int）和*之间，比如const int *p和int const *p，它修饰的是“指针指向的内容”；如果const在*之后、变量名之前，比如int *const p，它修饰的是“指针变量本身”。
第三步，用自然语言描述出来：先说出变量名，再描述它的类型层次，最后把const套进去。
举几个例子演示一下：
c复制char *strcpy(char *dest, const char *src);
这里const char *src：找到src，左侧是*，再左侧是const char，所以读作“src是一个指针，指向const char”。翻译成人话：通过src不能修改它指向的字符串内容。
c复制char *const argv[]; // 常见于main函数参数
数组元素类型是char *const，意思是每个元素本身是char *类型的const指针。读作“argv是一个数组，元素是const的char *指针”，也就是每个指针元素不可修改指向，但可以修改指针指向的字符内容。
c复制void (*signal(int sig, void (*func)(int)))(int);
这是函数指针的经典难题，不在本文核心范围，但用三步法依然能读：signal是函数，接收int和函数指针，返回函数指针。难点在于中间那一堆括号，建议单独练习。
3.2 int const *p 和 const int *p 完全等价，别被写法骗了
C语言标准规定，const int *p和int const *p含义完全相同。当const位于int左侧或右侧，只要它位于*左侧，修饰对象都是“指向的内容”。现实中这两种写法都大量存在，很多教科书甚至互相混用。为了减少思考成本，建议你自己写代码时统一使用const int *p，但看别人的代码时两种都要认得。
用一张表总结四种常见声明的性质和用途：
| 声明写法 | 指针本身可修改？ | 指向的内容可通过该指针修改？ | 常见用途 |
|---|---|---|---|
int *p |
是 | 是 | 默认普通指针，最常用 |
const int *p |
是 | 否 | 只读遍历、函数入参保护数据 |
int *const p |
否 | 是 | 固定缓冲区地址、寄存器映射 |
const int *const p |
否 | 否 | 只读固定地址，如查找表 |
注意，“指向的内容能否修改”是指在const限定之下，通过该指针不能修改。测试*p = 1是否会报编译错误即可。
3.3 一个容易误判的变形：typedef与const的结合
当指针类型被typedef包装后，很多人又开始犯迷糊。典型例子：
c复制typedef int *int_ptr;
const int_ptr p;
请问p是什么？很多人一看到const int_ptr就类比const int *，认为p是指向const int的指针。这是错的！因为typedef是类型的别名，const int_ptr等价于int *const p，即“p是指向int的const指针”。换句话说，typedef把指针类型作为一个整体，const修饰的是这个整体类型定义出来的变量，而不是指针解引用后的基础类型。
类似的坑还有：
c复制typedef int *int_ptr;
const int_ptr p1; // p1是 int *const
int_ptr const p2; // p2同样是 int *const
这段代码里的p1和p2等价，都是int *const。如果换成不用typedef的写法：
c复制int *const p1_equivalent;
int *const p2_equivalent;
对比就非常直观了。所以在阅读带typedef的指针声明时，先把typedef展开，再套用三步判别法，能避免绝大多数误判。
4. 为什么编译器会报这些错：常见错误信息与底层规则对照
这部分帮你建立“编译错误信息”和“底层含义”之间的映射关系。很多人死记硬背“常量指针不能改值”但不知道编译器看到什么才报错，导致换一个错法又看不懂。理解错误信息背后的检查规则，比你背十遍概念都有用。
4.1 最常见的四类编译错误
第一类错误：给指针常量赋值。代码与报错：
c复制int a = 1, b = 2;
int *const p = &a;
p = &b; // error: assignment of read-only variable 'p'
第二类错误：通过常量指针修改指向的数据。代码与报错：
c复制int a = 1;
const int *p = &a;
*p = 2; // error: assignment of read-only location '*p'
第三类错误：把const int *赋值给int *。代码与报错：
c复制const int a = 1;
const int *p = &a;
int *q = p; // error: initialization discards 'const' qualifier from pointer target type
第四类错误：通过非const指针修改const变量（如果编译不报错但运行期触发未定义行为）。代码与报错：
c复制const int a = 1;
int *p = (int *)&a; // 强制类型转换，把const去掉
*p = 2; // 试图修改const对象，结果未定义！
注意第四种，编译器在加(int *)强转后不会报警告，但运行时行为未定义。很多时候你写嵌入式代码，想修改一个被const限定的外设寄存器映射的只读区域，这种强转也许能骗过编译器，但它破坏了程序的内存安全假设，绝对不要在生产代码里这么干。
4.2 一个关于函数调用的典型编译错误
函数参数传递是const指针错误的重灾区。看下面这个简化版函数：
c复制void foo(int *p) {
*p = 10;
}
int main(void) {
const int a = 5;
foo(&a); // 编译错误！cannot convert 'const int*' to 'int*'
return 0;
}
&a的类型是const int *，而函数参数要求int *。如果你真的想在foo里修改这个值，正确的做法是把函数参数改成const int *p，或者接受一个可变副本。如果你确实需要修改，就要重新设计接口设计，而不是强转。
反过来呢？把一个int *传给const int *参数是可以的：
c复制void read_only(const int *p) {
printf("%d\n", *p);
}
int main(void) {
int a = 10;
read_only(&a); // 合法，把权限收窄
return 0;
}
这个方向是允许的，因为它只是“降低权限”，不会带来安全隐患。这也是为什么接口设计推荐“输入参数尽量用const限定”的原因之一——调用者可以传普通指针，函数内部保证不改，代码意图一目了然。
4.3 用编译器实测帮助理解
如果你手头有GCC，建议把这几个例子敲一遍，实际观察报错信息。我记得第一次在课堂上演示“assignment of read-only variable”和“assignment of read-only location”时，很多学生瞬间就明白了：一个是针对指针变量本身的只读属性，一个针对“指针指向的位置”的只读属性。两者的英文关键词都不同：
- read-only variable：变量本身只读，对应指针常量。
- read-only location：位置只读，对应常量指针的写作场景。
看报错措辞，能帮助你从编译器视角再次确认概念。在调试阶段，这两句英文提示比中文术语更直观。
5. 从笔试到嵌入式：这些场景才是真正考验水平的地方
学概念的最高境界是用。这一节我从三个最常见的实际场景入手，说说指针常量和常量指针在真实代码里是怎么出现、怎么用的，哪些坑是你即便理解了定义也容易踩的。
5.1 字符串字面量与指向它的指针
所有C语言初学者写过的代码：
c复制char *p = "hello";
这段代码在现代C标准下其实有问题——字符串字面量“hello”的类型是char[6]，存储在只读数据段。通过指针修改它属于未定义行为。更严格、更安全的写法是加const：
c复制const char *p = "hello";
p是“常量指针”吗？是的，const char *p表示通过p不能修改字符串内容。这里要注意，指针本身可以移动，所以p++是合法的，遍历字符串没问题；但*p = 'H'是非法的。下面是常见操作和合法性的快速判断：
| 操作 | 合法性 | 原因 |
|---|---|---|
p++ / p = p + 1 |
合法 | 指针本身不是const |
*p = 'H' |
非法 | 指向的是const char |
p[0] = 'H' |
非法 | 等价于 *p = 'H' |
printf("%c", *p) |
合法 | 只读访问完全允许 |
顺便提醒一个细节：char *p能直接赋值为字符串字面量，这是历史遗留的兼容性便利，但很多编译器的-Wwrite-strings选项会给出警告。所以新项目里尽量写const char *p，既能避免误改，也能让代码更规范。
5.2 嵌入式开发里的寄存器映射
如果你做嵌入式，寄存器映射绝对躲不开指针常量。单片机外设寄存器通常是固定地址，比如某芯片的GPIO配置寄存器地址是0x40021000。常规做法是用宏或指针常量定义：
c复制#define GPIO_CRL (*(volatile unsigned long *)0x40021000)
#define GPIO_CRH (*(volatile unsigned long *)0x40021004)
这里用到了指针常量+volatile的组合，但更多人会这样写：
c复制static unsigned long *const GPIO_CRL = (unsigned long *)0x40021000;
static unsigned long *const GPIO_CRH = (unsigned long *)0x40021004;
unsigned long *const表示这个指针本身不能改变，永远指向固定地址，但通过它可以读写该地址的内容。因为寄存器本来就是可读可写的，所以需要底层类型不带const。如果误写成了const unsigned long *，那么*GPIO_CRL = value就会编译失败，这常常是新手把设备驱动代码从普通变量改成寄存器映射时遇到的第一道坎。
5.3 函数参数设计的黄金法则
在写库函数、接口函数时，输入参数的const设计是有共识的，这个共识能帮你写出高可读性、低误用率的代码：
- 只读输入参数：用
const T *param，如size_t strlen(const char *s)。 - 读写参数：用普通指针，如
void *memcpy(void *dest, const void *src, size_t n)。注意源地址是只读的，目标地址可写，所以dest不带const，src带const。 - 指针本身不允许修改（固定缓冲区的首地址）：用
T *const param，但这种在接口参数里用得不多，更多用在内部变量上。 - 只读且不允许改指向：用
const T *const param，这种足够少见，通常是为了严格说明函数“不重新指向其他数据”。
一个有趣的反例是标准库strtok函数：
c复制char *strtok(char *str, const char *delim);
第一次调用传入原始字符串，之后传入NULL，内部会记住上次处理的位置。这里为什么第一个参数不用const char *str？因为函数要修改这个字符串，在内部会把分隔符替换成'\0'。所以它的参数是可写指针。如果你在代码里错误声明为const char *s再调用strtok，编译器立刻报错，因为参数类型不匹配。
5.4 指针常量和常量指针在“读代码”中的实战价值
我本人带项目时有一个习惯：凡是只读接口，参数一律加const。不是因为我死板，而是当后来的人接手代码时，光靠函数签名就能知道“这个函数不会改我的数据”，可以省去大量排查时间。我有一个亲身经历，一次在调试一个通信协议栈时，发现某个缓冲区的内容总被莫名修改，排查到后面才发现是某个函数内部写了一行buf[offset] = ...，而这个函数的参数声明是char *buf，当初就是漏了个const，导致维护者对“是否会修改缓冲区”产生了错误预期。如果一开始就用const char *buf，编译器会在那行写操作处直接报错，问题当场就暴露了。
这个经历也让我明白了一个道理：指针常量和常量指针的区别，不只是笔试考点，而是设计意图的表达方式。你在签名里写const，就是在告诉所有使用者“这个数据我只读，你不用担心被改”。这是代码自文档化的一个重要手段。
6. 高频笔试题与速记口诀：考前突击用这一篇就够了
最后这部分主要针对面试和考试场景。我整理了平时学生和读者问得最多的几类题目，每道都给出完整分析和速记要点。
6.1 十道典型辨析题
题目1：下面哪个声明是指针常量？
c复制A. const int *p
B. int const *p
C. int *const p
D. const int *const p
答案：C。A和B完全等价，是常量指针（指向const的指针）；C是指针常量（指针本身是const）；D两者都是。
题目2：const int *p;，p和*p哪个可修改？
答案：p可修改，*p不可通过p修改。
题目3：int *const p;，p和*p哪个可修改？
答案：p不可修改，*p可通过p修改。
题目4：int const *const p; 该如何解读？
答案：p是const指针，指向const int，两者都不可变。读作“p是一个const指针，指向const int类型数据”。
题目5：已知int a = 1; const int *p = &a;，下面哪个操作合法？
c复制A. p++;
B. (*p)++;
C. a++;
D. *p = 2;
答案：A和C合法。p++是改指针自身的指向，合法；a++是直接修改变量a，和p无关，合法；(*p)++和*p = 2都是通过p修改目标数据，不合法。
题目6：已有int a = 1; int *const p = &a;，下面哪个操作合法？
c复制A. p++;
B. (*p)++;
C. p = &a;
D. *p = 2;
答案：B和D合法。p++和p = &a都在尝试修改指针常量本身，非法；(*p)++和*p = 2修改指向的内容，合法。
题目7：函数声明void func(const int *p);，实参可以是int *吗？
答案：可以。权限从高到低传递（去掉修改权限）是安全的，能从int *隐式转换为const int *。
题目8：函数声明void func(int *p);，实参可以是const int *吗？
答案：不可以。权限从低到高（增加修改权限）是危险的，编译器会报错。
题目9：字符串字面量赋给哪种指针最安全？
答案：const char *p = "hello";。如果赋给char *p，虽然编译器通常只给警告不报错，但运行时修改字符串字面量属于未定义行为。
题目10：const int **pp; 和 int *const *pp; 有什么本质区别？
答案：前者表示“pp是指针，指向const int *类型的指针”，即最底层数据是const int；后者表示“pp是指针，指向int *const类型的指针”，即中间指针自身是const，但最底层数据是int，可通过**pp修改。
6.2 速记口诀与考场策略
总结多年经验，我推荐两条速记口诀。
口诀一：“const修饰最近者”。const出现在*左边，修饰的是“指针指向的东西”；出现在*右边，修饰的是“指针变量本身”。
口诀二：“读声明，从右往左读”。把int *const p;读作“p是const的指针，指向int”；把const int *p;读作“p是指针，指向const int”。注意观察：英文语序比中文更不容易混淆。
考场上的策略建议是，不要凭印象选答案。先把题目中的声明抄在草稿纸上，用“从右往左读法”写出中文含义，再对照选项判断。只要养成良好的读声明习惯，这2分基本是稳拿的。
6.3 一个容易被忽略的细节：const修饰的是“左结合”的哪个类型
最后补充一个细节。const int *p中，const本质上修饰的是int类型，但它可以放在int的左边或右边。同理，int *const p中，const修饰的是p这个指针变量。但在多级指针里，你可能会看到char const **pp这种写法，这等价于const char **pp，const修饰的还是最底层的char。所以不管const在类型名左边还是右边，只要它在*的左边（隔离了所有解引用层），它就修饰最终被指向的数据。
回忆一下，声明由“类型说明符+声明符”组成。const int *p的类型说明符是const int，声明符是*p，所以const作用于类型；int *const p的类型说明符是int，声明符是*const p，所以const作用于指针变量。这个角度更贴近C语言语法标准，也更能解释为什么const int *p和int const *p等价——因为二者类型说明符都是const int或int const，本质上都是“const限定的int类型”。
7. 写在最后的实操建议
我特别想强调一个观点：不要嫌概念小、基础，就跳过深入理解直接背答案。指针常量和常量指针这种知识点，表面上是语法辨析，实际上训练的是“读声明”的能力。一旦你把从右往左读声明的方法练成本能，再遇到char *const *(*next)()这类变态声明也不会慌。
在实际编程中，我有几条具体建议可以分享：
第一条，新写的代码里，凡是输入型指针参数，默认加const，除非你确定函数会修改它。这会让你的函数意图非常清晰，也让编译器帮你拦住不少低级错误。一开始可能觉得多打几个字母麻烦，但习惯了之后，你会发现自己代码的可读性提升一个档次。
第二条，定期做“声明阅读训练”。可以拿Linux内核头文件或者标准库头文件，随机找几个函数声明，尝试用从右往左读法把每个参数的类型说出来。每天十分钟，坚持一两周，无论是笔试还是日常开发，都会变得非常顺手。
第三条，遇到编译器报错时，不要急着改代码去“骗过编译器”，先读懂错误信息是在保护什么。比如遇到“discards qualifier”这类错误，先判断是不是你试图把const指针当成非const指针用。很多时候编译器报错不是阻碍你，而是替你在代码审查阶段发现了一个潜在bug。
文章写到这里，关于指针常量和常量指针的辨析、底层原理、实际应用、笔试题型基本都覆盖了。希望这篇总结能帮你把这个老生常谈的知识点彻底拿捏住，下次不管是考试、面试还是debug，都能在第一时间给出准确判断。