企业官网建设流程全解析

个人主页：https://blog.csdn.net/2501_93119704?spm=1000.2115.3001.5343欢迎大佬们互三

写在前面：指针和数组，其实是"一家人"

上一讲我们把"地址"和"指针变量"搞明白了。这一讲，很多人会栽在两个地方：一是数组名到底是不是指针（一会儿说是、一会儿又说 sizeof 例外），二是二级指针、指针数组这些"套娃"到底怎么回事。其实只要抓住一句话——数组名在绝大多数情况下就是首元素地址——后面的"指针访问数组、数组传参、指针数组"就全都串起来了。这篇复盘，我按"先吃透数组名 → 再用指针玩数组 → 最后上二级指针和指针数组"的顺序，把这一讲重新捋了一遍，配上图，争取一次讲透。

一、数组名的理解

1.1 数组名就是首元素的地址

上一讲用指针访问数组时，我们都是这样写的：

int arr[10] = {1,2,3,4,5,6,7,8,9,10}; int *p = &arr[0];

用&arr[0]拿到数组第一个元素的地址。但数组名arr本身就是地址，而且就是首元素的地址。做个测试：

#include <stdio.h> int main() { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; printf("&arr[0] = %p\n", &arr[0]); printf("arr = %p\n", arr); return 0; }

输出结果两个地址一模一样，证明：数组名就是数组首元素（第一个元素）的地址。

1.2 但是有两个"例外"

有同学马上会问：如果数组名是首元素地址，那下面的代码怎么解释？

#include <stdio.h> int main() { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; printf("%d\n", sizeof(arr)); // 输出 40，不是 4/8！ return 0; }

输出是40（10 个 int × 4 字节）。如果arr是首元素地址，sizeof(arr)应该输出 4（32 位）或 8（64 位）才对。

所以，"数组名是首元素地址"这个说法基本对，但有两个例外：

• sizeof(数组名)：sizeof里单独放数组名，这里的数组名表示整个数组，算的是整个数组的大小（字节）。
• &数组名：这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和首元素地址，+1 时的表现是有区别的，马上讲）。

除此之外，任何地方使用数组名，数组名都表示首元素的地址。

1.3 arr 和 &arr 到底差在哪

有好奇的同学再试这段：

#include <stdio.h> int main() { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; printf("&arr[0] = %p\n", &arr[0]); printf("arr = %p\n", arr); printf("&arr = %p\n", &arr); return 0; }

三个打印结果一模一样，都是同一个地址。那arr和&arr有啥区别？看+1就露馅了：

#include <stdio.h> int main() { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; printf("&arr[0] = %p\n", &arr[0]); printf("&arr[0]+1 = %p\n", &arr[0]+1); printf("arr = %p\n", arr); printf("arr+1 = %p\n", arr+1); printf("&arr = %p\n", &arr); printf("&arr+1 = %p\n", &arr+1); return 0; }

输出结果：

&arr[0] = 0077F820 &arr[0]+1 = 0077F824 arr = 0077F820 arr+1 = 0077F824 &arr = 0077F820 &arr+1 = 0077F848

看差值：

• &arr[0]和&arr[0]+1差4 个字节，arr和arr+1也差 4 字节——因为&arr[0]和arr都是首元素地址，+1就是跳过一个元素（一个 int 是 4 字节）。
• &arr和&arr+1差40 个字节——因为&arr是整个数组的地址，+1是跳过整个数组（10 个 int = 40 字节）。

🔑 结论：数组名是首元素地址，但有 2 个例外——sizeof(数组名)表示整个数组，&数组名表示整个数组的地址。&arr+1跳过整个数组，arr+1只跳过首元素。

二、使用指针访问数组

有了数组名的基础，再结合数组连续存放的特点，就能方便地用指针访问数组了：

#include <stdio.h> int main() { int arr[10] = {0}; int i = 0; int sz = sizeof(arr)/sizeof(arr[0]); int* p = arr; // arr 就是首元素地址，直接赋给 p // 输入 for(i = 0; i < sz; i++) { scanf("%d", p+i); // scanf("%d", arr+i); // 也可以这样写 } // 输出 for(i = 0; i < sz; i++) { printf("%d ", *(p+i)); } return 0; }

既然arr是首元素地址，可以赋给p，那arr和p在这里是等价的。那arr[i]能访问元素，p[i]能不能也访问呢？把上面输出里的*(p+i)换成p[i]，一样能正常打印：

for(i = 0; i < sz; i++) { printf("%d ", p[i]); }

🔑 结论：p[i]本质上等价于*(p+i)，同理arr[i]等价于*(arr+i)。数组元素的访问，编译器处理时也是"首元素地址 + 偏移量求出元素地址，再解引用"，和指针是一回事。

三、一维数组传参的本质

先抛个问题：数组能传给函数，那能不能在函数内部求数组元素个数？

#include <stdio.h> void test(int arr[]) { int sz2 = sizeof(arr)/sizeof(arr[0]); printf("sz2 = %d\n", sz2); } int main() { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; int sz1 = sizeof(arr)/sizeof(arr[0]); printf("sz1 = %d\n", sz1); test(arr); return 0; }

运行发现：sz1是 10（正确），但函数里的sz2是错的（32 位下输出 1，因为 4/4）。函数内部没有正确获得数组元素个数。

原因就是数组传参的本质：上一节我们说了，数组名是首元素地址；数组传参时传的是数组名，所以本质上传的是首元素的地址。函数形参部分应该用指针变量来接收首元素地址。既然形参本质是指针，sizeof(arr)在函数里算的就是一个地址的大小，而不是数组的大小。

所以函数形参写成数组形式还是指针形式，本质一样，都是指针：

void test(int arr[]) // 参数写成数组形式，本质上还是指针 { printf("%d\n", sizeof(arr)); // 算的是指针变量大小 } void test(int* arr) // 参数写成指针形式 { printf("%d\n", sizeof(arr)); // 也是指针变量大小 } int main() { int arr[10] = {1,2,3,4,5,6,7,8,9,10}; test(arr); return 0; }

🔑 总结：一维数组传参，形参部分可以写成数组形式int arr[]，也可以写成指针形式int* arr，两者等价。因为传的是首元素地址，所以函数里算不出数组长度，需要把元素个数另外传进来。

@@IMG3@@

四、冒泡排序

冒泡排序的核心思想就一句：两两相邻的元素进行比较。

方法 1（基础版）：

#include <stdio.h> void bubble_sort(int arr[], int sz) // 参数接收数组元素个数 { int i = 0; for(i = 0; i < sz-1; i++) { int j = 0; for(j = 0; j < sz-i-1; j++) { if(arr[j] > arr[j+1]) { int tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp; } } } } int main() { int arr[] = {3,1,7,5,8,9,0,2,4,6}; int sz = sizeof(arr)/sizeof(arr[0]); bubble_sort(arr, sz); int i = 0; for(i = 0; i < sz; i++) printf("%d ", arr[i]); return 0; }

方法 2（优化版）：加一个flag，如果某一趟一次都没交换，说明已经有序，直接提前结束，省掉后面的无用趟数：

#include <stdio.h> void bubble_sort(int arr[], int sz) { int i = 0; for(i = 0; i < sz-1; i++) { int flag = 1; // 假设这一趟已经有序 int j = 0; for(j = 0; j < sz-i-1; j++) { if(arr[j] > arr[j+1]) { flag = 0; // 发生交换，说明还无序 int tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp; } } if(flag == 1) // 这一趟没交换，说明已有序，后面不用排了 break; } } int main() { int arr[] = {3,1,7,5,8,9,0,2,4,6}; int sz = sizeof(arr)/sizeof(arr[0]); bubble_sort(arr, sz); int i = 0; for(i = 0; i < sz; i++) printf("%d ", arr[i]); return 0; }

这里正好用上了上一节"数组传参"的结论：bubble_sort的形参是int arr[]，本质是指针，所以函数里求不了元素个数，必须把sz也传进去。

五、二级指针

指针变量也是变量，是变量就有地址。那指针变量的地址存放在哪？——二级指针。

int a = 10; int* pa = &a; // pa 是"一级指针"，存 a 的地址 int** ppa = &pa; // ppa 是"二级指针"，存 pa 的地址

二级指针的运算就两条：

• *ppa：对 ppa 里的地址解引用，找到的是pa，所以*ppa访问的就是pa。

int b = 20; *ppa = &b; // 等价于 pa = &b;

• **ppa：先*ppa找到pa，再对 pa 解引用*pa，找到的是a。

**ppa = 30; // 等价于 *pa = 30; // 等价于 a = 30;

🔑 一句话：*ppa就是pa，**ppa就是a。每一层*都往"指向的对象"走一层。

六、指针数组

指针数组是"指针"还是"数组"？类比一下：整型数组是存放整型的数组，字符数组是存放字符的数组——那指针数组，就是存放指针的数组。

int* parr[3]; // 有 3 个元素的数组，每个元素都是 int* 类型（存放 int 的地址）

指针数组的每个元素都用来存放地址（指针），每个元素又是一个地址，可以指向一块区域。

判断"数组"还是"指针"的小技巧：看*和[]谁离名字近。int* parr[3]里，parr先和[3]结合，所以它是数组，数组里放的是int*。而int (*parr)[3]（数组指针，下一讲）是parr先和*结合，是指针。

七、指针数组模拟二维数组

指针数组的每个元素可以指向一块区域，那就可以用它模拟出"二维数组"的效果：

#include <stdio.h> int main() { int arr1[] = {1,2,3,4,5}; int arr2[] = {2,3,4,5,6}; int arr3[] = {3,4,5,6,7}; // 数组名是首元素地址，类型是 int*，可以放进 parr 数组 int* parr[3] = {arr1, arr2, arr3}; int i = 0, j = 0; for(i = 0; i < 3; i++) { for(j = 0; j < 5; j++) { printf("%d ", parr[i][j]); } printf("\n"); } return 0; }

• parr[i]访问的是parr数组的元素，parr[i]找到的这个元素（一个指针）指向了一个整型一维数组；
• parr[i][j]就是那个整型一维数组里的元素。

注意：上面只是模拟出了二维数组的效果，实际上它并非真正的二维数组，因为每一行（arr1/arr2/arr3）在内存里并不是连续的。真二维数组是整块连续的，这个区别下一讲会再展开。

总结

最后把这一讲的骨架拎出来：

1. 数组名：绝大多数情况是首元素地址；只有sizeof(数组名)和&数组名两个例外（都表示整个数组）。arr+1跳过 1 个元素，&arr+1跳过整个数组。
2. 指针访问数组：arr[i]==*(arr+i)，p[i]==*(p+i)，数组下标本质是"首地址 + 偏移再解引用"。
3. 数组传参：传的是首元素地址，形参int arr[]和int* arr等价；函数里求不了数组长度，要把sz另外传进去。
4. 冒泡排序：两两相邻比较；加flag优化，某一趟没交换就提前结束。
5. 二级指针：指针变量的地址用二级指针存；*ppa是pa，**ppa是a。
6. 指针数组：存放指针的数组，每个元素是一个地址；可用它模拟二维数组（但行与行不连续）。

一句话收尾：把"数组名 == 首元素地址"这句话刻进脑子，这一讲的内容就全打通了。

拓展学习

• 数组指针int (*p)[3]与指针数组的区别（《深入理解指针(3)》会继续讲）
• 一维/二维数组在内存中的真实排布，以及真正的二维数组怎么用指针访问
• 函数指针与回调函数（后续章节）
• 上一讲：深入理解指针(1)（地址、指针变量、const、野指针、传址调用）