【重点】你所知道的最全面的指针讲解！（二）

（二）

1.数组名的理解

在上一个博客里面我们在使用指针访问数组的时候，有这样的代码：

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

这里我们使用 &arr[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;
}

🔺让我们来看一下输出结果：

我们发现数组名和数组首元素的地址打印出的结果一摸一样，数组名就是数组首元素（第一个元素）的地址。

那么就有同学有疑惑了，数组名如果是数组首元素地址的话，该如何理解下面的代码呢？

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

🔺输出结果是40
_{这段代码的输出将是数组arr的大小，以字节为单位。在大多数现代系统上，一个int类型的大小是4字节，所以整个数组的大小将是40字节（10个整数*每个整数4字节）。因此，输出将是40。}

如果arr是数组首元素地址，那应该输出的是4/8才对。

其实数组名就是数组首元素地址（第一个元素）的地址是对的，但是有两个例外：
⭐ sizeof（数组名），sizeof 中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
⭐ &数组名，这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首元素的地址是有区别的）
⭐ 除此之外，任何地方使用数组名，数组名都表示首元素地址。

理论成立，实践开始！

#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**有什么区别呢？

我们看下面的代码：

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

★ 1.这里我们发现&arr[0]和&arr[0]+1相差4个字节，arr和arr+1相差4个字节，是因为&arr[0]和arr 都是首元素的地址，+1就是跳过一个元素。
★ 2.但是&arr和&arr+1相差40个字节，这就是因为&arr是数组的地址， +1操作是跳过整个数组的。

---

2.使用指针访问数组

当我们看懂前面的知识了后，结合数组的特点，我们就可以很方便的使用指针访问数组了。

#include <stdio.h>
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);
        // scanf("%d", arr + i);也可以这样写
    }
    //输出
    for (i = 0; i < sz; i++)
    {
        printf("%d `", *(p + i));
    }
    return 0;
}

🔺数组名arr是数组首元素，可以赋值给p，数组名 arr 和 p 是等价的。
🔺既然我们可以用arr[i]访问数组，p[i]同样也可以。

---

3.一维数组传参本质

首先我们从一个问题开始，我们之前都是在函数外部计算数组的元素个数，那我们可以把数组传给一个函数后，函数内部求数组的元素个数吗？

我们看一下下面的代码：

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

🔺我们发现函数内部是没有获得真正数组的元素个数。

⭐这个就要学习数组传参的本质：
数组名是数组的首元素地址；那么在数组传参的时候，传递的是数组名，也就是说本质上数组传参上传递的是数组首元素的地址
sizeof(arr)计算的是一个地址的大小(单位字节) 而不是数组的大小(单位字节)。正是因为函数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

_{注：一堆数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式}
(如果整个数组传过去了，占用空间会比较大，所以是不建议这样子做的喔)

---

4.冒泡排序

冒泡排序的核心思想就是：
1.两两相邻的元素进行比较。
2.若不满足顺序就交换
3.一趟冒泡排序搞一个数字

废话不多说，咱们上代码：

#include <stdio.h>

void bubble_sort(int arr[], int n) {   // 定义冒泡排序函数，参数为数组和数组长度
    int i, j, temp;   // 定义循环变量和临时变量
    for (i = 0; i < n - 1; i++) {   // 外层循环，控制比较轮数
        for (j = 0; j < n - i - 1; j++) {   // 内层循环，控制每轮比较次数
            if (arr[j] > arr[j + 1]) {   // 如果相邻元素大小顺序不对，则交换它们的位置
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = { 64, 34, 25, 12, 22, 11, 90 };   // 定义一个整数数组
    int n = sizeof(arr) / sizeof(arr[0]);   // 使用sizeof运算符计算数组的大小，再除以一个元素的大小来计算元素的个数
    bubble_sort(arr, n);   // 对数组进行冒泡排序
    printf("Sorted array: ");   // 输出排序后的结果
    for (int i = 0; i < n; i++) {   // 使用循环遍历数组中的每个元素
        printf("%d ", arr[i]);   // 将它们输出到屏幕上
    }
    printf("\n");
    return 0;
}

🔺超级详细的注释，认真理解就完事啦！

该代码中，bubble_sort函数实现了冒泡排序算法。它使用两个嵌套的循环来比较相邻的元素，如果前面的元素比后面的元素大，则交换它们的位置。这样一趟遍历后，最大的元素就会被交换到数组的最后面。然后对剩下的元素再进行一次遍历，直到整个数组都被排序。

在主函数中，我们定义了一个整数数组arr，并使用sizeof运算符计算数组的大小。然后我们调用bubble_sort函数对该数组进行排序，并输出排序后的结果。

---

5.二级指针

指针变量也是变量，有变量就有地址，那指针的变量的地址存放在哪里呢？

• 对于二级指针的运算有两点：

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

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

2. **ppa 先通过 *ppa 找到pa，然后进行解应用操作： *pa，那找到的是a

**ppa = 30;
//等价于 *怕= 30；
//等价于a = 30；

6.指针数组

说到指针数组，那必然要和数组指针在一起比较，我们只需要记住几点就好了

⭐指针数组——每个元素都用来存放地址（指针）——是数组
⭐数组指针——指向数组的指针——是指针

7.指针数组模拟二维数组

用我们学习到的知识，用指针数组模拟二维数组想必简简单单，洒洒水啦

上代码：

#include <stdio.h>

int main() {
    int rows = 3, cols = 4;   // 定义二维数组的行数和列数
    int arr[rows][cols];      // 定义一个二维数组
    int i, j;                 // 定义循环变量

    // 为二维数组赋值
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            arr[i][j] = i * cols + j;
        }
    }

    // 使用指针数组模拟二维数组
    int* p = arr[0];          // 定义一个指向数组的指针，将其赋值为数组的第一个元素的地址
    for (i = 0; i < rows; i++) {
        printf("Row %d: ", i);  // 输出当前行的行号
        for (j = 0; j < cols; j++) {
            printf("%d ", *(p + j));  // 输出当前行的每个元素
        }
        printf("\n");
    }

    return 0;
}

🔺该代码中，我们首先定义了一个二维数组arr，并使用两层循环为其赋值。然后我们使用一个指向数组的指针p来模拟二维数组。我们将指针初始化为二维数组的第一个元素的地址，然后使用循环遍历每个元素，并使用解引用操作符（*）来访问它们的值。这样就可以实现对二维数组的访问和操作了。

---

待完
创作不易，这次一定：）