/* MD / 富文本中的 .toc(含博客园搬家等嵌套结构);.toc-box 在侧栏,不受影响 */
#content_views .toc,
/* 编辑器常在目录前后插入空 p(:empty 仍占 20px),一并去掉避免顶空隙 */
#content_views.markdown_views > p:empty:has(+ .toc),
#content_views.markdown_views > .toc + p:empty,
/* 富文本旧版目录标记 */
#content_views.htmledit_views #main-toc,
#content_views.htmledit_views #hr-toc,
#content_views.htmledit_views p[id*=\”-toc\”] {
display: none !important;
}
/* 目录去掉后,紧跟的首个标题不再多出一块上边距 */
#content_views.markdown_views > .toc + h1,
#content_views.markdown_views > .toc + h2,
#content_views.markdown_views > .toc + h3,
#content_views.markdown_views > .toc + h4,
#content_views.markdown_views > .toc + p:empty + h1,
#content_views.markdown_views > .toc + p:empty + h2,
#content_views.markdown_views > .toc + p:empty + h3,
#content_views.markdown_views > .toc + p:empty + h4 {
margin-top: 0 !important;
}
数组退化与二维数组指针:从 *(*(arr+1)+1) 说起
初学 C 语言的人几乎都会被 *(*(arr + 1) + 1) 这种表达式劝退。它看起来像一串乱码,其实背后只有一个概念在起作用——数组退化(array decay)。把这一层理解透了,这串符号就变成了可以一步步算出来的算术题。
先看一段代码,看完你可能会有疑问:
#include <stdio.h>
int main()
{
int arr[3][4] = {
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9,10,11,12 }
};
printf("%p\\n", arr); // 假设输出 00000000000003E8(即 1000)
printf("%p\\n", arr + 1); // 输出 00000000000003F8(即 1016)
printf("%d\\n", *(*(arr + 1))); // 输出 5
printf("%d\\n", *(*(arr + 1) + 1));// 输出 6
return 0;
}
第一个疑问通常是:为什么 arr + 1 跳了 16 字节,而不是 4 字节? 第二个疑问是:那两个星号到底在干什么? 要回答它们,得从数组退化讲起。
一、什么是数组退化
一句话定义:
数组名在大多数场合会"自动变成"首元素的地址,这个过程叫数组退化(decay)。
打个比方:数组本来是一整排座位(比如 10 个),但你一问它"你在哪",它只肯报"第一个座位的门牌号",后面 9 个座位的信息一概不提。信息被丢掉了,这就是退化。
int arr[10];
int* p = arr; // arr 变成了 &arr[0]
func(arr); // 传进去的是地址,不是整个数组
printf("%p", arr); // 还是地址
arr + 1; // 等于 &arr[0] + 1
上面这些场合,arr 都不再代表"10 个 int 的整体",而只是一个 int*。
二、什么时候不会退化?只有三个例外
数组名并不是任何时候都会退化,例外只有三处,考试和面试都爱考:
| sizeof(arr) | 整个数组的字节数 | 例外 ① |
| &arr | 整个数组的地址,类型 int(*)[10] | 例外 ② |
| char s[] = "abc" 初始化 | 按字符数组处理 | 例外 ③ |
除此之外,数组名只要出现在表达式里,就一律退化成首元素地址。
记住这张表的方式是反着记:只有 sizeof 和 & 这两个运算符"还认得出数组是整体",其他运算符眼里数组只是个地址。
int arr[10];
sizeof(arr); // 40(10 × 4),没退化
sizeof(arr + 0); // 8(指针大小),退化了!
第二行特别值得玩味:仅仅是加了个 + 0,sizeof 的结果就从 40 变成了 8。因为 arr + 0 已经是一个表达式,数组名在其中退化了,sizeof 量的就是一个指针。
三、为什么会退化
两个原因,都很朴素。
原因 1:效率。 C 的设计哲学是"不偷偷替你干活"。假如 func(arr) 真的把 40 字节复制一份传进去,每次调用都白烧时间和内存。传个地址只要 8 字节,最省。至于要不要复制,C 把这个决定权交给你。
原因 2:机器层面数组本来就没有独立身份。 C 被称为"高级汇编",在硬件眼里只有"一块连续内存 + 一个起始地址",没有"数组"这个对象。数组名只是程序员方便用的标签,退化才是内存的真实面貌。
理解了这一点,后面所有的"坑"其实都不算坑,而是C 语言如实反映了底层。
四、四个高频误区
误区 1:在函数里用 sizeof 求数组长度
这是最经典的一个,几乎人人踩过:
void printLen(int arr[10]) // 形参写成 [10] 也没用
{
printf("%d\\n", sizeof(arr)); // 输出 8,不是 40!
}
int main()
{
int arr[10];
printf("%d\\n", sizeof(arr)); // 输出 40 ✅
printLen(arr); // 输出 8 ❌
return 0;
}
根因:函数形参 int arr[10] 在编译器眼里其实就是 int* arr——形参里的方括号是写给人看的,不产生任何约束。所以函数内部永远不知道数组有多长。
这也解释了为什么标准库函数都要额外传长度:
void* memcpy(void* dest, const void* src, size_t n); // n 是必须的
void qsort(void* base, size_t nmemb, size_t size, ...); // nmemb 是必须的
正确的写法是把长度单独传:
void printLen(int arr[], int n)
{
for (int i = 0; i < n; i++)
printf("%d ", arr[i]);
}
误区 2:以为 arr 和 &arr 是一回事
数值相同,类型不同,步长差 10 倍:
int arr[10];
printf("%p\\n", arr + 1); // 起始地址 + 4 字节
printf("%p\\n", &arr + 1); // 起始地址 + 40 字节
arr 是 int*(步长 4),&arr 是 int(*)[10](步长 40)。数值一样不等于类型一样,这道题在选择题里出现频率极高:
int* p = NULL;
int arr[10] = { 0 };
p = arr; // ✅ arr 退化为 &arr[0],类型 int*
p = &arr[0]; // ✅ 首元素地址,类型 int*
p = &arr; // ❌ &arr 是 int(*)[10],类型不兼容,编译报错
误区 3:想用 = 复制数组
int a[5] = {1,2,3,4,5};
int b[5];
b = a; // ❌ 编译错误:数组名退化成常量地址,不能被赋值
数组名是"常量地址",不能当左值。想复制只能循环或 memcpy:
memcpy(b, a, sizeof(a));
误区 4:arr++ 报错,但 p++ 可以
int arr[5];
int* p = arr;
arr++; // ❌ arr 是常量地址,不能修改
p++; // ✅ p 是变量,随便挪
数组名退化成的是常量指针,它的值(地址)不可改;而 p 是真正的变量。
五、二维数组:退化只退一半
一维数组退化会丢掉"长度",二维数组退化会保留列数——这是它有意思的地方。
int a[3][10];
func(a); // a 退化成 &a[0],类型是 int(*)[10]
为什么是 int(*)[10] 而不是 int*?因为二维数组的元素本身就是"一行"——a[0] 是一个含 10 个 int 的数组。退化时它退成"指向行"的指针,行的宽度(10)被记住了,只有"一共几行(3)"丢了。
这直接导致一个必须记住的规则:
void f(int arr[][10]); // ✅ 列数必须写
void f(int arr[3][]); // ❌ 编译错误
void f(int arr[][]) ; // ❌ 编译错误
行数可以省,列数不能省——因为退化后编译器要靠列数计算步长,否则不知道 arr + 1 该跳多远。
六、三次"剥洋葱":*(arr+1) 系列
现在正式拆解开头那串表达式。用 int arr[3][4],假设起始地址 1000,每个 int 占 4 字节,一行 4 个共 16 字节。
int arr[3][4] = {
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9,10,11,12 }
};
第一层:arr + 1 —— 还剩"行"的身份
printf("%p", arr + 1); // 1016,不是 1004
arr 退化成 int(*)[4](行指针),它仍然知道"我指的是一整行 4 个 int",所以 +1 跳过 16 字节,跨到第二行。
第二层:*(arr + 1) —— 解一层,降级成元素指针
printf("%p", *(arr + 1)); // 还是 1016
对行指针解引用,得到的是"这一行这个数组";而数组名在表达式里又要退化,于是它变成 int*,指向 arr[1][0]。
地址值没变,类型变了——这是最关键的一步:
- arr + 1 是 int(*)[4],步长 16 字节
- *(arr + 1) 是 int*,步长 4 字节
所以紧接着的 +1 只跳 4 字节:
printf("%p", *(arr + 1) + 1); // 1020
第三层:*(*(arr + 1)) —— 再解一层,拿到值
printf("%d", *(*(arr + 1))); // 5,即 arr[1][0]
第二层 * 是对 int* 解引用,取到实际的 int 值。
第四层:*(*(arr + 1) + 1) —— 拿到 6
内层 *(arr + 1) + 1 是 int* 往后挪一个,指向 arr[1][1];外层 * 取值 → 6。
完整对照表
| arr | int(*)[4] | 1000 | — | 指向第 0 行 |
| arr + 1 | int(*)[4] | 1016 | — | 第 1 行整行 |
| *(arr + 1) | int* | 1016 | — | arr[1],第 1 行首元素地址 |
| *(arr + 1) + 1 | int* | 1020 | — | &arr[1][1] |
| *(*(arr + 1)) | int | — | 5 | arr[1][0] |
| *(*(arr + 1) + 1) | int | — | 6 | arr[1][1] |
退化的两次降级
int[3][4] ← 原身份:3 行 4 列的整块
↓ 表达式里退化
int(*)[4] ← 还剩"行指针":知道一行多宽,不知道共几行
↓ 解一层 *,又退化
int* ← 只剩"元素指针":只知道指向一个 int
↓ 再解一层 *
int ← 值本身,退化结束
每解一层 *,就丢掉一层"整块信息"。这也是为什么 arr + 1 跳 16 字节,而 *(arr + 1) + 1 只跳 4 字节——它们虽然指向同一块内存,但类型不同,步长不同。
七、顺手收下这个公式
有了上面的推导,二维数组的下标公式就不用背了,可以自己推出来:
arr[i][j] ≡ *(*(arr + i) + j)
编译器看到 arr[i][j],内部就是这么翻译的——方括号只是指针运算的语法糖。
所以遇到 *(*(arr + 1) + 1) 这类题,不要在脑子里硬记,按两步算:
推广到三维数组也一样:arr[i][j][k] ≡ *(*(*(arr + i) + j) + k)——每多一维,就多一层 *,也再多一次退化。
八、总结速查
| 函数实参、指针赋值、算术运算、printf | 退化 |
| sizeof(arr)、&arr | 不退化 |
| 函数形参 int arr[] / int arr[10] | 已退化(等价 int*) |
| 二维数组传参 | 退化成行指针 int(*)[列数] |
三句话收尾:
把这三句记住,再看 *(*(arr + 1) + 1) 这种表达式,它就不再是魔法,而是一道可以一步一步算出来的算术题。
本文示例代码在 VS2022 / gcc 下均验证通过。不同平台的地址数值可能不同(64 位系统指针为 8 字节),但类型关系与步长结论完全一致。
网硕互联帮助中心


![[LangChain] 学习笔记(06):突破大模型限制——结构化输出(Structured Output)-网硕互联帮助中心](https://www.wsisp.com/helps/wp-content/uploads/2026/11/20261107204100-6aef8cdc87ece-220x150.png)




评论前必须登录!
注册