C语言指针2：数组名、二级指针、指针数组，一次把“指针和数组“讲透

个人主页：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、野指针、传址调用）