1. 这道题为什么值得单独拿出来讲先说一个我见过太多遍的场景笔试面试问*p和(*p)的区别回答的人十个里有六个会卡壳。卡壳不是因为不懂指针也不是因为不懂自增而是因为*、、括号这三样东西凑在一起时优先级和结合性的规则在脑子里搅成了一团浆糊。更麻烦的是这四个表达式实际执行时的内存变化比纸面上的规则复杂得多尤其是自增发生在取值之前还是之后、自增的是指针还是指针指向的值这两条线如果没理清楚写出的代码就是定时炸弹。先亮结论方便后面展开表达式含义自增对象取值时机*p先取p指向的值再让p指向下一个位置指针p本身自增前*p先让p指向下一个位置再取新位置的值指针p本身自增后*p把p指向的值加 1p指向的数据先取值再加(*p)取p指向的值作为结果然后把该值加 1p指向的数据自增前取值这个表格背下来不难难的是理解为什么是这样以及实际写代码时在哪几种场景下会用到它们。这篇博文我就把这四个表达式彻底拆开从优先级规则讲到内存变化再结合几个真实的编码场景把容易踩的坑也一并说清楚。内容适配从刚学指针的初学者到需要写底层解析代码的进阶开发者只要你在用 C 语言处理数组、遍历字符串、操作缓冲区这篇就值得看完。2. 优先级与结合性的本质先搞清楚规则再谈应用2.1 后缀自增的优先级高于解引用前缀自增则相反*p这个表达式里有两个运算符*解引用和自增。但有后缀形式和前缀形式两种而这两种形式在优先级表里的位置完全不同这才是最容易被忽略的关键点。看 C 语言运算符优先级表从高到低只列相关的优先级运算符结合性1最高()函数调用、[]下标、-、.、后缀、后缀--左到右2前缀、前缀--、*解引用、取地址、!、~、、-、sizeof右到左3*乘法、/、%左到右注意看后缀待在最高优先级那一档而前缀和解引用*一起待在第二档而且第二档的结合性是右到左。这就直接推导出两个结论在*p中因为没有括号优先级最高的是后缀所以编译器先把p看成一个整体。p的含义是表达式的结果是p的旧值副作用是让p自增。然后*作用于这个结果也就是对p的旧值解引用。因此*p等价于先取*p再把p后移一位。在*p中是前缀形式和解引用*同一优先级结合性右到左所以先算p再算*作用于p的结果。p的结果是p自增后的新值于是*p等价于先把指针后移一位再解引用新地址。这个规则看起来简单但真正写代码时人脑经常绕不过弯。我的建议是不要靠背靠拆。拿到一个复杂表达式先画括号把隐式的结合顺序显式化再去读语义。2.2 后缀自增表达式的值与副作用分离后缀自增是理解这类问题的第二把钥匙。p这个表达式在 C 语言标准里包含两部分表达式的值p在自增之前的旧值。副作用p这个变量本身被修改指向下一个位置。这两件事发生的时间点很关键。C 语言标准规定副作用在下一个序列点之前的某个时刻完成即可并不是说先取值然后立刻自增。但在我们讨论的这四个表达式里没有逗号、没有逻辑与或、没有三元运算符这些引入序列点的东西整个表达式本身构成一个序列点所以实际行为是确定的先取旧值作为表达式结果在同一表达式结束前完成自增。举一个非常容易出错的例子int arr[3] {10, 20, 30}; int *p arr; printf(%d\n, *p); // 输出 10之后 p 指向 arr[1] printf(%d\n, *p); // 输出 20第一行*p中p的值是arr[0]副作用让p变成了arr[1]所以*作用于arr[0]取出 10。此时p已经指向了arr[1]所以第二行输出 20。如果把第一行换成printf(%d\n, (*p)); // 输出 10但 arr[0] 变成 11p 没动 printf(%d\n, *p); // 输出 11(*p)中(*p)先解引用得到arr[0]的值 10然后后缀自增作用于这个值表达式的值是 10副作用是arr[0]被写回 11。整个过程中p始终没有变化所以第二行输出 11。这两组对比放在一起*p和(*p)的区别就非常清晰了前者自增的是p指针搬家后者自增的是*p数据变值。2.3 括号改变的是组合顺序不是运算顺序(*p)里括号的作用是什么它把*p强制绑定成一个整体让后缀作用于*p这个左值而不是作用于p。这里要引入左值的概念。在 C 语言中*p是一个左值它代表一块内存区域你可以对它读取也可以对它写入。当后缀作用于一个左值时它要求这个左值必须是可以修改的modifiable lvalue。*p满足这个条件前提是p指向的不是const修饰的数据。*p又是另一回事。前缀的优先级和解引用*相同结合性右到左所以它等价于(*p)即先取*p作为左值然后把这个左值指向的数据加 1表达式的值是加 1 之后的新值。而(*p)表达式的值是加 1 之前的旧值。这个值不同的差异在某些场景下会产生 bug后面我会专门举例。3. 四个表达式逐个拆解优先级跟内存变化同步看3.1*p先取值后移动指针这是四个表达式里最常用、也最容易和(*p)混淆的一个。它的语义拆解如下int arr[4] {5, 6, 7, 8}; int *p arr; int val *p; // 等价于 // int val *p; // p p 1;用汇编视角看编译器通常会把*p编译成类似这样的指令序列把p的当前值加载到寄存器。用该寄存器作为地址从内存中读取一个int大小的数据存入目标变量。把p的值增加sizeof(int)也就是 4 字节32 位系统下。关键在于第 2 步和第 3 步的先后关系——先读取、后移动。即使某些编译器为了优化调整了指令顺序但最终结果必须符合先取旧值解引用、再自增指针的语义。实际跑一段代码验证#include stdio.h int main(void) { int arr[4] {5, 6, 7, 8}; int *p arr; int first *p; printf(first %d, *p %d, p - arr %ld\n, first, *p, p - arr); // 输出first 5, *p 6, p - arr 1 return 0; }first拿到 5随后p指向arr[1]p - arr的值为 1。这个行为完美解释了为什么*p是遍历数组的经典写法——每次从当前位置取一个数据然后把指针挪到下一个位置循环体内什么都不用多想。3.2*p先移动指针后取值*p和*p一字之差行为却完全相反。语义拆解int arr[4] {5, 6, 7, 8}; int *p arr; int val *p; // 等价于 // p p 1; // int val *p;如果p初始指向arr[0]执行完*p后p先变成arr[1]再解引用取出 6。注意这里表达式的结果是arr[1]的值而指针最终落在arr[1]上。这个表达式在什么场景下有用有一个典型的例子——解析以特殊标记开头的缓冲区。假设一个数据包的结构是头字节 有效载荷头字节指示了有效载荷的长度你想直接跳过头部读取载荷的起始地址用*p就很自然。unsigned char *cursor buffer; // buffer[0] 是长度字段 int payload_len *cursor; // 读取长度 unsigned char first_payload *cursor; // 先跳过长度字段再读取第一个载荷字节当然你也可以先cursor再*cursor但*p把两步合成一步语义一目了然。不过我得提醒一句这种写法虽然简洁但在团队协作中会让读代码的人多停顿一下不是所有人都能瞬间反应过来。减少这类组合表达式的嵌套长度是提高可读性的重要原则。3.3*p给指针指向的值加 1指针不动*p没有括号但根据优先级前缀和*同级、右结合所以它等价于(*p)。作用于左值*p效果是把p指向的那个数据加 1。代码验证#include stdio.h int main(void) { int x 100; int *p x; int result *p; printf(result %d, x %d\n, result, x); // 输出result 101, x 101 return 0; }x从 100 变成 101p的指向全程没变表达式的结果是自增后的新值 101。这个表达式的典型应用场景是计数器累加。比如统计字符出现频率int freq[256] {0}; const char *text hello world; while (*text) { freq[(unsigned char)*text]; text; }freq[...]的本质就是对数组元素做加 1 操作这里的前缀形式比freq[...] freq[...] 1更简洁也比后缀形式freq[...]少一次临时值的产生虽然现代编译器优化后两者几乎没有性能差异但语义上前缀表达式的值更符合累加后取新值的逻辑。3.4(*p)取旧值后加 1指针不动(*p)是后缀自增作用于左值*p。它和*p的区别在于表达式的值(*p)的值是自增前的旧值*p的值是自增后的新值。但副作用相同——p指向的数据最终都加了 1。代码验证#include stdio.h int main(void) { int x 100; int *p x; int result (*p); printf(result %d, x %d\n, result, x); // 输出result 100, x 101 return 0; }注意int result (*p);这一行result拿到的是 100而x变成了 101。(*p)的典型场景在需要记录旧值的处理流程里。比如实现一个数据缓冲区的读取游标既要返回当前位置的数据又要让计数加一typedef struct { int *data; int length; int read_index; } BufferReader; int read_next(BufferReader *reader) { if (reader-read_index reader-length) { return -1; // 越界保护 } return reader-data[reader-read_index]; }这里我把read_index的自增用在了数组下标里相当于data[read_index]这种逻辑的变体不要和(*p)搞混但它们的思想是一致的先取旧值再把计数加一。如果用前缀形式就会变成先加一再取值整个读取逻辑会错位一位。3.5 横向对比表一张表彻底分清四个表达式单独讲完每个表达式后把它们放一起做对比更直观。假设int x 10; int *p x;初始状态是*p 10表达式等价写法*p执行后的值表达式自身的值指针p是否变化*p*(p)10不变10*p旧值是后移一位*p*(p)取决于新位置不是原来这个x了新位置的*p值是先移再取*p(*p)1111新值否(*p)(*p)1110旧值否如果上面这张表你只看最后两列就抓住了核心前两个表达式动指针后两个动数据动数据的两个里前缀表达式返回新值后缀表达式返回旧值。这个总结足够应对 90% 的面试题和日常编码判断。4. 实际应用数组遍历、解析器实现和链表操作4.1 用*p简化数组遍历代码遍历一个整数数组并累加所有元素初学者通常这样写int sum 0; for (int i 0; i n; i) { sum arr[i]; }如果引入指针可以写成int sum 0; int *p arr; int *end arr n; while (p end) { sum *p; }两种写法功能完全相同但第二种在需要同时保留数组起始地址的场景下更有优势。*p每次循环体里把一个元素累加进去同时移动指针代码非常紧凑。更重要的是p本身作为游标移动而arr始终指向数组开头这在某些调试场景下很实用——你随时能通过p - arr算出当前读到了第几个元素。用指针遍历字符串是另一个经典场景。在 C 语言里字符串就是char数组以\0结尾。计算字符串长度的标准库strlen内部大致就是这个逻辑size_t my_strlen(const char *s) { const char *p s; while (*p) { // 空循环体*p 已经做了取值和指针移动 } return p - s - 1; }这里*p的用法比较微妙while (*p)先取出当前字符如果非零就继续循环同时指针已经后移。循环终止时p指向的是\0的下一个位置所以长度是p - s - 1。注意这里用const char *修饰s和p表示只读遍历防止误写。我自己在嵌入式开发中处理串口收包的环形缓冲区时也常用这种写法uint8_t rx_buffer[64]; uint8_t *rx_head rx_buffer; void on_byte_received(uint8_t byte) { *rx_head byte; // 写入当前指针位置然后后移 if (rx_head rx_buffer sizeof(rx_buffer)) { rx_head rx_buffer; // 绕回环形缓冲区头部 } }*rx_head byte是*p的一种变体只不过这里*p作为赋值表达式的左值部分先解引用取到当前写入位置把数据写进去再把指针后移。这种写指针后移的模式在处理 FIFO、队列、连续存储时非常常见。4.2 用*p跳过头部直取数据解析器里的顺手工具*p的语义是先移动指针再取值这个特性决定了它的应用场景通常是需要跳过某个固定长度的头部或标记直接读取后续数据。举个例子解码一个简单的 TLV 格式数据包Type-Length-Value假设buffer指向一个类型字节、一个长度字节、紧接着是length个数据字节uint8_t *cursor buffer; uint8_t type *cursor; // 读 Type指针移到 Length uint8_t len *cursor; // 读 Length指针移到 Value 起始 uint8_t first_value_byte *cursor; // 读第一个 Value 字节这里我用的是*cursor而不是*cursor。如果要合并最后两步可以这样uint8_t type *cursor; uint8_t len *cursor; uint8_t first_value_byte *cursor; // 在已经指向 Length 的 cursor 上先移到 Value 再取值但说实话*cursor这种写法在可读性上不如分开写。它会强迫读者去回忆此时cursor到底指向哪。我的经验是在解析器这类对正确性要求极高的代码里每一步都写清楚比省两行代码重要得多。*p的真正价值更多体现在以下这种场景// 从堆栈中弹出并读取顶部元素的下一个字段 int value *stack_ptr;这里stack_ptr先移动到栈顶位置再解引用取值。用一句话概括*p的应用场景当指针的当前位置是上一个数据的边界而你需要直接读取下一个数据时用*p可以少写一次临时变量。4.3 用*p与(*p)处理计数和状态机*p和(*p)都作用于指针指向的数据区别只在表达式的值。实际开发中这两者在状态机、引用计数、循环控制方面有各自的用武之地。引用计数场景假设你写了一个内存池每个对象有一个引用计数。释放时减少计数计数归零才真正回收内存。这里减少计数并判断结果的场景适合用前缀形式int ref_count 5; int *cnt ref_count; while (--(*cnt) 0) { // 还有引用不释放 } // 此时 *cnt 0执行释放逻辑--(*cnt)的值是自减后的新计数直接用来判断是否归零。如果用后缀形式(*cnt)--判断的却是旧值逻辑上就反了。状态机计数器场景如果需要一个计数器每次加一但在加之前要把旧值传给某个函数就应该用后缀形式int (*p_counter) packet_count; int current (*p_counter); send_report(current); // 上报的是自增前的旧值这个场景和(*p)的语义完全匹配先把旧值取出来用再把计数器加一。再举一个更贴近底层的例子——操作某个外设寄存器的标志位。假设寄存器地址通过指针REG访问其中某一位是传输完成标志处理完标志后需要清除它volatile uint32_t *REG (volatile uint32_t *)0x40001000; uint32_t old (*REG); // 读取当前寄存器值然后把值加 1这个例子不一定真实但展示了(*p)的思想读取旧值、副作用更新数据、指针不动的三合一。在硬件寄存器编程中这种读-改-写模式经常会用到。4.4 链表遍历中的指针移动优先级问题的隐藏地雷链表是 C 语言面试和底层开发绕不开的话题。链表遍历中有一个典型的隐藏地雷——释放节点后指针的移动顺序。// 删除链表中的所有节点 while (head ! NULL) { free(head); head head-next; // 错误head 已经被 free访问 head-next 是未定义行为 }正确写法while (head ! NULL) { Node *next head-next; free(head); head next; }这个例子虽然不是直接的*p问题但背后是同一类思维指针操作和副作用发生的时机必须严格规划。在head head-next这种写法里右侧先读head-next还是先执行free(head)影响了代码正确性。C 语言标准没有规定函数调用参数求值和相邻语句之间的执行顺序但free(head)一旦执行head指向的内存就已失效再访问head-next就是典型的 use-after-free。同理如果你在遍历链表时想用*p风格的代码移动指针一定要确保p发生在解引用之前已经安全完成的前提下。比如while (p ! NULL) { process(p-data); void *next p-next; // 先保存 next p next; // 再移动指针 }这里的p next不能替换成p因为节点在内存中不是连续的自增指针只适用于连续数组。*p只能用于连续存储区域数组、缓冲区绝不能用在不连续的数据结构链表、树、图上。这是一个必须反复强调的边界条件。5. 优先级陷阱排查一个完整的调试案例纸上谈兵到这里看一个真实翻车案例。我有一个项目需要统计文本中每个字母的 ASCII 码出现次数最初写的代码是这样的int freq[128] {0}; char *p text; while (*p ! \0) { *p freq[*p]; // 意图把当前字符的计数加一 }这段代码的问题很多但最核心的错误在于freq[*p]和*p同时出现时的执行顺序冲突。*p的自增副作用发生在整个表达式求值完成前还是完成后表达式*p freq[*p]中左侧*p先求出左值解引用旧p然后要求值右侧的freq[*p]此时p是否已经自增如果已经自增*p在右侧就不再指向原来的字符——这是未定义行为的典型隐患。排查这个问题的链路如下发现问题程序输出结果完全错误很多字符计数为 0有些字符计数异常大。缩小范围把赋值语句拆开while (*p ! \0) { freq[*p]; // 先计数 p; // 再移动指针 }修改后程序立刻正确。此时能确认问题出在*p和freq[*p]组合的求值顺序上。定位原因C 语言标准规定如果一个表达式在两个序列点之间多次修改同一个标量对象行为是未定义的。在这个表达式里*p修改了p而freq[*p]读取了p读取和修改之间没有序列点分隔所以实际结果取决于编译器怎么生成代码。不同编译器、不同优化级别结果可能完全不一样——这正是最坑的地方。修复方案永远不要在一行里既修改指针又用这个指针索引其他数据。要么先取值后移动要么干脆写成两行。这个案例给所有人的教训就一条当表达式里同时出现副作用和读取同一变量时立刻停下来拆行。现代编译器很聪明但 C 语言标准留给编译器的自由度不应该是你秀操作的空间。类似地printf(%d %d\n, *p, *p)这种代码也是未定义行为因为函数参数的求值顺序在 C 语言标准里没有规定多个参数各自修改了p结果随编译器而定。我在面试时经常拿这种代码当题目让候选人解释输出结果其实正确回答是不要纠结输出这行代码本身就是错的。能说出这句话的人才算是真正理解了序列点和副作用的含义。6. 常见的误用场景与自检方法我总结了六条最容易踩坑的规则每一条都有对应的自检方法。6.1 误用一把*p用在链式数据结构上前面提过*p的自增操作是基于指针算术的只适用于连续内存。如果p指向链表节点执行p不会让p指向下一个逻辑节点而是指向当前节点内存地址的下一个字节——这通常是野指针。自检方法写代码前问自己一句这个指针的自增是否会到达一个合法且有意义的内存位置如果答案是不确定就不要用指针自增改用显式的p p-next。6.2 误用二混淆(*p)和*(p)这两个表达式字形相似语义完全不同。(*p)自增的是数据*(p)等价于*p自增的是指针。我见过一个 bug在缓冲区解析代码里程序员想跳过当前字节自增指针却写成了(*p)结果字节值被修改指针不动后续所有解析全部错位。排查了两天才找到问题。自检方法看到*和紧挨着时先画出隐式括号(*p)、*(p)、(*p)、*(p)再逐层分析。慢一点但不会错。6.3 误用三对const限定对象使用*p或(*p)如果p是const int *p那么*p是只读左值不能作为自增操作的目标。这会导致编译错误。这在语义上是好事——编译器帮你挡住了错误。自检方法确认指针类型。const int *p表示指向常量的指针int *const p表示指针本身是常量。前者不能修改数据后者不能修改指针。写自增表达式前先判断你要修改的是数据还是指针再看这个目标是否可修改。6.4 误用四自增结果赋给自身比如*p *p;这种表达式既是未定义行为又没有任何实际意义。即使抛开标准层面的问题这种写法也无法清晰表达把一个位置的值复制到另一个位置的意图。正确做法int tmp *src; // 先取源值源指针后移 *dst tmp; // 写入目标目标指针后移自检方法把赋值语句拆成读源、写目标、移动源指针、移动目标指针四个动作任何合并大于两个动作的写法都值得怀疑。6.5 误用五在宏定义中使用带副作用的参数这是 C 语言宏的老坑。假设你定义了一个宏#define INCREMENT_AND_GET(x) (*(x))如果调用时传的是pINCREMENT_AND_GET(p)宏展开后变成(*(p))p被自增了两次而不是一次。宏参数只是文本替换不保证只求值一次。自检方法带副作用的表达式不要塞进宏参数里也不要塞进函数宏的参数里。如果必须用宏先取临时变量再传入。6.6 误用六忽略运算对象类型导致指针步长错误p让指针前移多少字节取决于p指向类型的大小。如果p是char *前移 1 字节如果p是int *前移sizeof(int)字节通常是 4如果p是struct Node *前移整个结构体的大小。同一个在不同指针类型下移动的字节数完全不同。这个规则既是便利也是陷阱。在泛型编程或内存操作场景下如果拿void *指针做自增很多编译器直接报错因为void类型的大小不确定。正确做法是先转成char *或unsigned char *void *ptr buffer; unsigned char *byte_ptr (unsigned char *)ptr; byte_ptr; // 明确移动 1 字节自检方法看到指针自增先想清楚指针的基类型是什么再判断移动的字节数是否符合预期。7. 调试技巧和编译器辅助怎么快速验证自己的判断如果你写了这四个表达式之一但不确定自己的理解是否正确有几种办法可以快速验证不用凭感觉猜。方法一打印指针差值在数组环境中用p - arr的输出值就能看到指针移动的步数int arr[5] {1, 2, 3, 4, 5}; int *p arr; printf(%ld\n, p - arr); // 0 *p; printf(%ld\n, p - arr); // 1指针差值的类型是ptrdiff_t用%ld格式化时注意平台差异更稳妥的是强制转换成long或long long。方法二反汇编验证在 GCC 下用-S选项生成汇编代码在-O0和-O2两种优化级别下分别查看*p对应的指令。-O0下通常能看到清晰的读内存-地址加步长两条指令-O2下编译器可能会做各种等价变换但语义不变。这个方法适合想深入学习的人能直观感受编译器对表达式的处理。方法三用 static_assert 或断言语义检查如果在写库代码想确保某个表达式不会引发未定义行为可以在代码里加断言// 确保 p 指向的数据可以修改 _Static_assert(!__is_const(p), pointer target must be modifiable);不过__is_const是 GCC 扩展跨平台性一般生产代码里更常见的是靠类型系统的const限定来自动约束不需要手动断言。方法四利用在线编译器快速实验想快速对比不同表达式行为可以开 Compiler Explorergodbolt.org左边写 C 代码右边直接看汇编输出。把*p、*p、*p、(*p)分别写在不同函数里观察汇编指令的差异比对着书本啃规则直观得多。8. 这段经验不是背出来的是踩出来的最后说几句掏心窝的话。这四个表达式看起来只是优先级知识点的延伸但我在实际项目里被它们坑过不止一次。最严重的一次是在一个网络协议解析模块里我写了一个类似value *buf的表达式但buf是uint16_t *我误以为它移动 1 字节结果整个数据包解析全部错位排查了一个下午才发现是步长问题。从此我给自己定了一条规矩凡是涉及指针自增的代码一定要在注释里写明指针基类型和移动步长。另一个深刻的体会是代码的可读性比简洁性重要得多。while (*p ! \0)这种写法确实简洁但如果你不能保证团队里每个人都秒懂那它就可能在 code review 时浪费更多时间。我自己写项目时如果是核心算法或协议解析宁可拆成两行也不硬凑。也正因如此我建议初学者把这些表达式当作理解优先级和副作用的训练题而不是当作必须频繁使用的技巧。熟练掌握它们的目的不是鼓励你在代码里炫技而是让你在遇到别人写的这类代码时能准确判断它的行为不慌不乱。面试时能解释清楚、写代码时不犯错这才是这段知识的真正价值。如果你想继续深入可以往这几个方向扩展C 语言标准里关于序列点和副作用的完整规则、restrict关键字对指针别名的影响、volatile 指针在访问硬件寄存器时的语义变化这些都是和指针优先级相辅相成的底层主题。把这四个表达式吃透等于给后续深入 C 语言底层机制打好了地基。