云计算百科
云计算领域专业知识百科平台

数组退化与二维数组指针:从 *(*(arr+1)+1)说起

/* 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。

完整对照表

表达式类型地址(base=1000)值等价的写法
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,每次跳"一行字节数"(4 列 × 4 字节 = 16)
  • 再行内偏移:+ j,每次跳"一个元素字节数"(4)
  • 最后取值:最外层 * 拿到数据
  • 推广到三维数组也一样:arr[i][j][k] ≡ *(*(*(arr + i) + j) + k)——每多一维,就多一层 *,也再多一次退化。


    八、总结速查

    你在写什么数组退化了吗
    函数实参、指针赋值、算术运算、printf 退化
    sizeof(arr)、&arr 不退化
    函数形参 int arr[] / int arr[10] 已退化(等价 int*)
    二维数组传参 退化成行指针 int(*)[列数]

    三句话收尾:

  • 数组名是个"只会报门牌号"的家伙——除了 sizeof 和 &,其他场合一律只给首元素地址。
  • 退化的本质是丢信息:一维丢长度,二维丢行数,只留列宽。
  • 每解一次 * 就降一级:行指针 → 元素指针 → 值。
  • 把这三句记住,再看 *(*(arr + 1) + 1) 这种表达式,它就不再是魔法,而是一道可以一步一步算出来的算术题。


    本文示例代码在 VS2022 / gcc 下均验证通过。不同平台的地址数值可能不同(64 位系统指针为 8 字节),但类型关系与步长结论完全一致。

    赞(0)
    未经允许不得转载:网硕互联帮助中心 » 数组退化与二维数组指针:从 *(*(arr+1)+1)说起
    分享到: 更多 (0)

    评论 抢沙发

    评论前必须登录!