深入理解指针（2）

数组名的理解

什么是数组名？在计算机编程中，数组名是用于标识一个数组的名称。那应当如何来理解数组名呢？事实上，在数组中数组名就是数组首元素的地址。

示例1：

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

可以看出，两者的结果是相同的。数组名表示的是整个数组，也就是数组首元素的地址。

使用指针访问数组

指针访问数组，指针如何来访问数组呢？在深入理解指针（1）中我们讲到，指针等价于地址，而数组和指针是等价的，这就导致指针访问数组就很容易了。

示例2：

//案例1：
#include<stdio.h>
int main() {
	int arr[3] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	for (int i = 0; i < sz; i++) {
		scanf("%d", p + i);
	}
	for (int i = 0; i < sz; i++) {
		printf("%d", *(p + i));
	}
	return 0;
}
//案例2：
#include<stdio.h>
int main() {
	int arr[3] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	for (int i = 0; i < sz; i++) {
		scanf("%d", p + i);
	}
	for (int i = 0; i < sz; i++) {
		printf("%d", p[i]);
	}
	return 0;
}

一维数组传参的本质

学过数组的同学们一定知道数组是可以传给函数的，那么数组传参的本质是什么？

示例3：

#include<stdio.h>

void test(int arr[]) {
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("sz= %d\n", sz);
}
int main() {
	int arr[3] = { 0 };
	int szs = sizeof(arr) / sizeof(arr[0]);
	printf("szs= %d\n", szs);
	test(arr);
	return 0;
}

同学们，这段代码反映了什么问题呢？仔细一看发现，函数内部并没有正确获取数组的元素个数。我们知道，数组名是数组首元素的地址，那么数组传参传的实际上是数组名，然后对其进行解引用，也就是说本质上数组传参传递的是数组首元素的地址。因此，在函数内部是没有办法求数组元素的个数的。

总的来说，一维数组的传参，形参部分可以写成数组的形式，也可以写成指针的形式。

二级指针

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

示例4：

#include<stdio.h>
int main() {
	int a = 10;
	int* pa = &a;
	int** pc = &pa;
	printf("%d\n", a);
	printf("%p\n", pa);
	printf("%p\n", pc);
	return 0;
}

在这段代码中，*pc通过对ppa中的地址进行解引用，这样找到的是pa，*pc其实访问的就是pa。

而**pc先通过*pc找到pa，然后对pa进行解引用操作，那么*pa找到的就是a。

这便是二级指针。

二级指针在动态数组中的应用（拓展）

• 动态二维数组：在处理动态分配的二维数组时，二级指针非常有用。例如：

示例5：

#include <stdio.h>
#include <stdlib.h>

int main() {
    //创建一个3行4列的矩阵
    int rows = 3;
    int cols = 4;

    // 分配二维数组
    int** matrix = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int*)malloc(cols * sizeof(int));
    }

    // 使用二维数组
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * cols + j;
        }
    }

    // 打印二维数组
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;
}

拓展

冒泡排序

关于冒泡排序还是比较总要i的，同学们还是要重视一下。

原理：相邻的两个元素两两相比较，一次找出最大或者最小的那一个。

代码实现：

void bubble_sort(int arr[], int sz) {
	for (int i = 0; i < sz - 1; i++) {
		int f = 1;
		for (int j = 0; j < sz - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				f = 0;
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
		if (f == 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);
	for (int i = 0; i < sz; i++) {
		printf("%d", arr[i]);
	}
	return 0;
}