指针（2）
目录
✨ 引言：
数组和指针是 C 语言的 “黄金 CP”💑—— 很多新手觉得它们晦涩难懂，其实核心就一句话：“数组靠指针访问，指针靠数组落地”！这份笔记从数组名的本质、指针访问数组，到二维数组模拟，全是实战干货。
1. 📌 数组名的本质：是地址，不是数组！
很多人一上来就搞错：int arr[10]中的arr，默认不是整个数组，而是数组首元素的地址！只有两种特殊情况会 “变身”。
1.1 数组名的默认身份：首元素地址
数组名就像快递的 “收件地址前缀”，默认指向第一个包裹（首元素）的位置：
int main()
{
int arr[10] = { 0 };
int* p1 = &arr[0]; // 直接取首元素地址（常规操作）
int* p2 = arr; // 数组名arr等价于&arr[0]（默认身份）
return 0;
}
🤔 结论：数组名 ≈ 首元素地址（默认情况下），所以能直接赋值给指针变量。
1.2 数组名的两个 “特殊身份”（例外情况）
只有当数组名出现在 sizeof(数组名) 和 &数组名 中时，才会 “变身” 为整个数组的代表：
int main()
{
int arr[10] = { 0 };
// 1. 普通情况：arr是int*类型，+1跳4字节（1个int）
printf("arr = %p\n", arr); // 0019FBE0
printf("arr+1 = %p\n", arr+1); // 0019FBE4（+4字节）
// 2. &arr[0]和arr等价，+1同样跳4字节
printf("&arr[0] = %p\n", &arr[0]); // 0019FBE0
printf("&arr[0]+1 = %p\n", &arr[0]+1);// 0019FBE4（+4字节）
// 3. 特殊情况1：&arr → 取整个数组的地址，类型是int(*)[10]（数组指针）
// &arr+1 → 跳过整个数组（10×4=40字节），不是跳1个int！
printf("&arr = %p\n", &arr); // 0019FBE0（地址值和首元素相同，但类型不同）
printf("&arr+1 = %p\n", &arr+1); // 0019FC08（+40字节）
// 4. 特殊情况2：sizeof(arr) → 计算整个数组的大小（10×4=40字节）
printf("%zd\n", sizeof(arr)); // 40（不是指针大小！）
return 0;
}
📌 核心区别（必记！）：
arr→ 类型int*→ +1 跳 4 字节；&arr→ 类型int(*)[10]→ +1 跳 40 字节；sizeof(arr)→ 只认整个数组，和指针无关！
通俗比喻：
数组名arr平时是 “小区门牌号”（首元素地址），别人按这个地址能找到第一个住户；&arr是 “整个小区的产权证明”，代表所有住户（整个数组）；sizeof(arr)是 “小区占地面积”，算的是所有住户的总空间。
2. ⚡ 指针访问数组：地址运算的 “魔法”
数组在内存中是连续存储的，而指针 ± 整数的 “步长特性”，刚好能精准遍历每个元素 —— 这就是指针访问数组的底层逻辑！
int main()
{
int arr[10] = { 0 };
int sz = sizeof(arr) / sizeof(arr[0]); // 计算元素个数（10）
int* p = arr; // p指向首元素，和arr等价
int i = 0;
// 输入10个值：p+i = &arr[i]（指针+整数=目标元素地址）
for (i = 0; i < sz; i++)
{
scanf("%d", p + i); // 直接用指针地址接收输入
}
// 输出10个值：*(p+i) = arr[i]（解引用地址=元素值）
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
// 等价写法（见证魔法！）：
// arr[i] = p[i] = *(arr+i) = *(i+arr) = i[arr]
// 后两种写法合法但不推荐，可读性太差！
}
return 0;
}
💡 核心公式（刻在脑子里！）：arr[i] = *(arr + i) → 数组下标访问的本质是地址运算！不管是arr[i]还是p[i]，最终都是通过 “首地址 + 偏移量” 找到元素。
3. 🚚 一维数组传参：传的是地址，不是数组！
这是新手最容易踩的坑：数组传参时，函数接收的不是 “整个数组”，而是数组首元素的地址！形参数组其实是 “伪装的指针”。
3.1 形参数组的 “假象”（易错点复刻）
void Print(int arr[10/*可以省略*/]) // 这里的arr是int*指针，不是数组！
{
// 致命错误：sizeof(arr)计算的是指针大小（4/8字节），不是数组大小！
int sz = sizeof(arr) / sizeof(arr[0]); // 32位平台：sz=4/4=1
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d", arr[i]); // 只输出第一个元素1，因为sz=1
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
Print(arr); // 传的是首元素地址（0X0012ff40），不是整个数组
return 0;
}
❌ 为什么错？
- 编译器会自动把形参
int arr[]或int arr[10]转换成int* arr； - 所以
sizeof(arr)得到的是指针大小（32 位 4 字节，64 位 8 字节），不是数组总大小。
3.2 正确传参：地址 + 长度缺一不可
必须在主函数中计算数组长度，再传给函数
📌 总结：数组传参的本质是 “传地址”，形参没有数组的 “灵魂”（不占数组空间），所以必须带长度！
4. 🔄 冒泡排序：指针思维优化排序效率
冒泡排序是数组 + 指针的经典实战 —— 核心逻辑是 “两两相邻比较，大值后移”，结合指针能更高效实现，还能优化循环次数！
4.1 冒泡排序核心逻辑
- 趟数：n 个元素需要 n-1 趟（最后一个元素不用比）；
- 比较次数：第 i 趟需要比较
sz-1-i次（后 i 个元素已排好序）； - 目标：每一趟把当前最大的元素 “冒泡” 到末尾。
4.2 关键优化：有序标志位（原码复刻 + 详解）
void bubble_sort(int arr[], int sz) // arr本质是int*指针
{
int i = 0;
for (i = 0; i < sz - 1; i++) // n-1趟排序
{
int flag = 1; // 有序标志位：1=当前趟有序，0=无序
int j = 0;
// 每趟比较sz-1-i次（排除已排好的末尾元素）
for (j = 0; j < sz - 1 - i; j++)
{
if (arr[j] > arr[j + 1]) // 前元素>后元素，交换
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
flag = 0; // 发生交换，说明还没完全有序
}
}
if (flag == 1) // 本趟无交换，数组已有序，直接退出！
{
break;
}
}
}
void Print_arr(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
int main()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz); // 排序后：0 1 2 3 4 5 6 7 8 9
Print_arr(arr, sz);
return 0;
}
✨ 优化效果：如果数组已经部分有序（比如1,2,3,5,4），第一趟交换 4 和 5 后，第二趟无交换，直接退出 —— 比传统冒泡少跑很多次循环！
指针思维解读：
arr[j]和arr[j+1]本质是*(arr+j)和*(arr+j+1)，排序过程就是通过指针偏移访问元素、交换值的过程。
5. 🎯 二级指针：指针的 “套娃” 玩法
二级指针是 “存放指针地址的指针”—— 听起来绕，其实就是 “地址的地址”，用 “套娃” 比喻秒懂！
核心定义（原码复刻）
int main()
{
int a = 10; // 普通变量：值=10，地址=&a
int *p = &a; // 一级指针：值=&a，地址=&p
int** pp = &p; // 二级指针：值=&p，地址=&pp
int*** ppp = &pp; // 三级指针（以此类推，很少用）
return 0;
}
内存布局 “套娃” 图：
| 变量 | 存储的值 | 地址 | 类型 | 作用 |
|---|---|---|---|---|
| a | 10 | 0x0012ff40 | int | 存实际数据 |
| p | 0x0012ff40（&a） | 0x0012ff48 | int* | 存 a 的地址（一级指针） |
| pp | 0x0012ff48（&p） | 0x0012ff50 | int** | 存 p 的地址（二级指针） |
二级指针访问数据（原码复刻 + 解读）
int main()
{
int a = 10;
int* p = &a;
int** pp = &p;
printf("%p\n", *pp); // 输出&a（0113FDC0）：*pp = p（解引用二级指针得到一级指针）
printf("%d\n", **pp); // 输出10：**pp = *p = a（两次解引用得到原数据）
printf("%p\n", &a); // 输出&a（0113FDC0）：和*pp值相同
return 0;
}
🤔 比喻：a 是 “快递包裹”（数据），p 是 “写着包裹地址的纸条”（一级指针），pp 是 “写着纸条地址的信封”（二级指针）—— 要拿到包裹，得先拆信封（*pp）拿到纸条，再按纸条地址找包裹（**pp）。
6. 🏗️ 指针数组：用指针 “拼” 出二维数组
指针数组是 “每个元素都是指针的数组”—— 它能把多个独立的一维数组 “拼接” 起来，模拟出二维数组的访问效果！
6.1 指针数组的定义（原码复刻）
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
int* arr[] = { arr1, arr2, arr3 }; // arr是指针数组，3个元素都是int*类型
📌 解读：
arr[0]=arr1（指向第一个一维数组首元素）；arr[1]=arr2（指向第二个一维数组首元素）；arr[2]=arr3（指向第三个一维数组首元素）。
6.2 模拟二维数组：访问方式与底层原理（原码复刻）
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
int* arr[] = { arr1, arr2, arr3 }; // 指针数组“拼接”二维数组
int i = 0;
for (i = 0; i < 3; i++) // 遍历3行（3个一维数组）
{
int j = 0;
for (j = 0; j < 5; j++) // 遍历每行5列
{
printf("%d ", arr[i][j]); // 等价于*(*(arr+i)+j)
}
printf("\n"); // 换行分隔
}
return 0;
}
输出结果：
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
底层原理拆解：
arr[i][j] = *(*(arr+i)+j)
arr+i：找到指针数组的第 i 个元素（即指向第 i 个一维数组的指针）；*(arr+i)：解引用得到第 i 个一维数组的首地址（=arr[i]）；*(arr+i)+j：偏移 j 个元素，得到第 i 行第 j 列元素的地址；*(*(arr+i)+j)：解引用得到目标元素值。
关键补充（区别于真正的二维数组）：
- 指针数组模拟的二维数组：每行内存不连续（arr1、arr2、arr3 是独立数组）；
- 真正的二维数组（
int arr[3][5]）：整个数组内存连续； - 但访问方式完全相同（都用
arr[i][j]），这就是指针数组的灵活之处！
🎉 总结：数组与指针的 “爱恨情仇”
- 数组名本质是首元素地址，仅
sizeof(数组名)和&数组名例外； - 数组下标访问的底层是地址运算（
arr[i] = *(arr+i)）； - 数组传参传地址，形参是指针，必须带长度；
- 二级指针是 “指针的指针”，用于存储指针地址；
- 指针数组能模拟二维数组，访问灵活但每行内存不连续。
其实数组和指针的核心就是 “地址”—— 数组是 “连续地址的集合”，指针是 “存储地址的变量”，两者联手能搞定 C 语言中大部分复杂的内存访问场景！
如果这篇博客帮你理清了思路，欢迎点赞收藏🌟～
扫一扫
1326
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
