14 指针 · 其二 · 数组-CSDN博客

本文链接：https://blog.csdn.net/m0_66277256/article/details/140325439

一、数组名的理解

（一）【数组名】与【&数组名[0]】

（二）区别于【 sizeof(数组名) 】和【 &数组名】

一、数组名的理解

（一）【数组名】与【&数组名[0]】

【数组名】与【&数组名[0]】表示的都是数组首元素的地址，如下代码演示：

#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;
}

在x86环境下，输出结果如下：

结论：【数组名就是数组首元素(第一个元素)的地址】

（二）区别于【 sizeof(数组名) 】和【 &数组名】

数组名就是首元素的地址，但是有2个例外：

sizeof(数组名)，sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节；

&数组名，这里的数组名表示整个数组，取出的是整个数组的地址

区别演示：

① 【&数组名】的打印结果与【数组名】和【&数组名[0]】是一样的，但【数组名】和【&数组名[0]】表示的是数组首元素的地址（数组名 == &数组名[0]），而【&数组名】表示的是整个数组的开头地址。演示代码如下：

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;
}

在x86环境下，输出结果如下：

② 【数组名】和【&数组名[0]】与【&数组名】的地址都＋1后，【数组名】和【&数组名[0]】跳过4个字节，也就是一个数组元素，而【&数组名】跳过【4*数组】个字节，也就是整个数组的长度。如下代码演示：

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;
}

在x86环境下，输出结果如下：

结果显示&arr[0]和&arr[0]+1相差4个字节，arr和arr+1 相差4个字节，是因为&arr[0] 和 arr 都是首元素的地址，+1就是跳过⼀个元素；

但是&arr 和 &arr+1相差40个字节，因为&arr是整个数组的地址，+1 操作是跳过整个数组；

（三）总结

以后只看见【数组名】就表示首元素的地址，【&数组名】就表示整个数组的地址；

说到底，最内核的原因还是指针类型的不同造成的差异：上面例子中，【数组名】的指针类型是int* ，而【&数组名】的指针类型为 int (*) [10]

二、使用指针访问数组

利用【数组名就是首元素的地址】知识点，通过指着访问数组；代码如下：

int main()
{
    int arr[10] = {0};
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);

    int* p = arr;
    for(i=0; i<sz; i++)
    {
    scanf("%d", p+i);//输入，也可以写成 arr+i
    }

    for(i=0; i<sz; i++)
    {
        printf("%d ", p[i]); //输出，等同于arr[i]
    }

    return 0;
}

arr[ i ] == *(arr + i) == *(i + arr) == i [arr] ；

上述等式的理解：[ ] 仅仅是一个操作符而已，arr 与 i 是操作数；类比 a+b 等同于 b+a，同样只是交换了操作数，结果是完全一致的，但反过来写的可读性不高

总结：

数组，就是一块连续的空间，可以存放一个或多个数据
指针变量，就是一个变量，可以存放地址
数组和指针不是一回事，但是可以通过指针来访问数组，因为：
- 数组在内存中是连续的
- 指针的运算可以很方便遍历数组，取出数组的内容

三、一维数组传参的本质

一维数组传参的本质：传递的是数组首元素的地址，所以形参即使写成数组的形式，本质上也是一个指针，所以形参理应写成指针形式，而形参写成数组的形式，只是为了新手方便了解；

当数组传参的时候，形参可以写成数组，也可以写成指针；

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;
}

注意：通常情况下，数组传参包括：【数组名，数组元素个数】

四、冒泡排序

冒泡排序的核心思想：两两相邻的元素比较，不满足顺序（升序）就交换，满足就找下一对；

思路如下：

首先，确定趟数，一趟冒泡排序解决一个数字，当有n个元素时，排序完 n-1个元素后，剩下一个元素就是最小的，就不用排序了，所以一共需要排 n-1 趟；

然后时每一趟内部的比较，比如有10个元素，第一趟比较9对，第二趟比较8对......会随着趟数变化，所以是 n-1-i；

void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
    for(int i=0; i<sz-1; i++)
    {
        int flag = 1;//假设这⼀趟已经有序了
        for(int 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;
}

五、二级指针

指针变量也是变量，是变量就有地址，那么指针变量的地址就存放在二级指针

代码分析：二级指针的 *，表示ppa是指针变量，而 int* 表示ppa指向的变量类型是int*；二级指针用来存放一级指针的地址

二级指针的运算如下：

① *ppa：通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa

int b = 20;
*ppa = &b;

*ppa == pa

② **ppa：先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a

**ppa = 30;

**ppa == *pa == a

注：二维数组和二级指针没有对应关系

六、指针数组

指针数组：存放指针（地址）的数组

类比：
字符数组： char arr[20]

字符指针数组： char* arr[20]，这里arr先和[20]结合，里面存放的是char*

整型数组： int arr[20];

整型指针数组： int* arr[20]

需要批量存放or使用指针时，可以用数组来存放指针进行使用，也就是使用指针数组

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

模拟二维数组：

一维数组的首地址存放在一个指针数组里面，即可模拟二维数组

#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};


    for(int i=0; i<3; i++)
    {
        for(j=0; j<5; j++)
        {
            printf("%d ", parr[i][j]);
        }
        printf("\n");
    }

    return 0;
}

parr [ i ][ j ] == *(*(parr + i) + j)

分析：parr表示 int* parr[3] 指针数组的首元素的地址，也就是指向arr1的地址，可以通过指针运算：parr + i，找到每一个数组（arr1 或 arr2 或 arr3）的首元素指针，然后解引用 *(parr + i)，就可以得到数组的首元素地址arr1 或 arr2 或 arr3，再通过指针运算*(parr + i) + j，就可以找到每个数组元素的地址，*(*(parr + i) + j)解引用后就得到了每个元素。