【C语言学习】深入理解指针（2）

1. 数组名的理解

前面我们在使用指针访问数组内容的时候，有这样的代码：

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

在这里我们使用 &arr[0] 的方式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，而且是数组首元素的地址。
我们来进行测试：

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

运行结果：

我们发现数组名和数组首元素的地址打印出的结果一模一样，数组名其实就是数组首元素(第⼀个元素)的地址。
可能会有小伙伴会有疑问：如果数组名是数组首元素的地址，那下面的代码该怎么解释呢？

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

运行结果：

按照我们刚才的结论，如果arr是数组首元素地址的话，那输出的结果应该是4/8才对。这里怎么会打印40呢？
其实数组名就是数组首元素(第⼀个元素)的地址是对的，但是有两个例外：
1.sizeof(数组名)，这里的数组名表示的是整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节。
2.&数组名，这里的数组名表示整个数组，&数组名：取出的是整个数组的地址。
出来以上两种情况，其余遇到的数组名都是首元素的地址。
接下来，我们再来看一段代码：

#define _CRT_SECURE_NO_WARNINGS
#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到底有啥区别呢？

诶，别急接下来我们慢慢分析其中的原因：

#define _CRT_SECURE_NO_WARNINGS
#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]和&arr[0]+1相差4个字节，arr和arr+1 相差4个字节，这是因为&arr[0] 和 arr 都是首元素的地址，+1就是跳过⼀个元素。
但是&arr 和 &arr+1相差40个字节，这是因为&arr是数组的地址，+1 操作是跳过整个数组。
讲到这儿，小伙伴应该搞清楚数组名的意义了吧😊。

2. 使用指针访问数组

有了前⾯知识的支撑，再结合数组的特点，我们就可以很方便的使用指针来访问数组了。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int arr[10] = { 0 };
	//[][][][][][][][][][]
	//0 1 2 3 4 5 6 7 8 9
	int sz = sizeof(arr) / sizeof(arr[0]);
	//输入
	int* p = arr;
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		scanf("%d", p + i);
	}
	//输出
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
		//printf("%d ", *(arr + i));
		//printf("%d ", arr[i]);
		//printf("%d ", p[i]);
		//arr[i]==*(arr+i);
		//*(p+i)==p[i];
		
		//事实上，arr[i] == *(arr + i) == *(i + arr) == i[arr]
		//printf("%d ",i[arr]);//3+5//5+3——不推荐这种写法
	}
	return 0;
}

运行结果：

3. 一维数组传参的本质

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

#define _CRT_SECURE_NO_WARNINGS
#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) /sizeof(arr[0])来计算的其实是⼀个地址的大小（单位字节）而不是数组的大小（单位字节）。正是因为函数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void print1(int arr[])//参数写成数组形式，本质上还是指针
{
	printf("%d\n", sizeof(arr));
}

void print2(int arr[])//参数写成指针形式
{
	printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩
}

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	print1(arr);
	print2(arr);
	return 0;
}

两个结果都是4或者8！
总结：⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

4. 冒泡排序

冒泡排序的核心思想就是：两两相邻的元素进行比较。
下面举一个例子为大家介绍冒泡排序：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void sort(int* arr, int sz)
{
	//确定冒泡排序的趟数
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (*(arr + j) > arr[j + 1])//这里两边可以改用一样的写法
			{
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

void print(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
}

int main()
{
	int arr[] = { 9, 3, 2, 5, 4, 7, 8, 6, 1 };
	//我们需要排序，排为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	sort(arr, sz);
	print(arr, sz);
	return 0;
}

运行结果：

当然，我们也可以通过引入变量临时变量flag对上述代码进行优化：

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

void print(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i<sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr[] = { 9, 3, 2, 5, 4, 7, 8, 6, 1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	print(arr, sz);
	return 0;
}

运行结果：

5. 二级指针

指针变量也是变量，是变量就需要在内存中划分一块区域来存放，那指针变量的地址存放在哪里呢？
答案是二级指针。

#define _CRT_SECURE_NO_ARNINGS
#include <stdio.h>

int main()
{
	int a = 10;
	int * p = &a;//p是一级指针
	//a是整形变量，占用4个字节的空间，&a拿到的就是a所占4个字节的第一个字节的地址
	//p是指针变量，占用4/8个字节的空间，p也有自己的地址，&p就拿到了p的地址
	int* * pp = &p;

	**pp--> a;
	//pp也是指针变量，pp是二级指针变量
	int** * ppp = &pp;//ppp是三级指针
	//...
	return 0;
}

二级指针画图

对于二级指针的运算有：
1.*pp 通过对 pp 中的地址进行解引用，这样找到的是 p，*pp 其实访问的就是p。

int a = 10;
*pp = &a;

**2.pp 先通过 *pp 找到 p，然后对 p 进行解引用操作：*p，那找到的就是a。

**pp = 10;
//等价于*pp = &a;
//等价于**pp = a;
//等价于a = 30;

6. 指针数组

首先，我们得思考一个问题：指针数组是指针还是数组？
我们类比一下：
整形数组—存放整形的数组 int arr[10]
字符数组—存放字符的数组 char ch[5]
那么指针数组就应该是存放指针的数组，指针数组的每个元素都是用来存放地址（指针）的。
如下图：

指针数组的每个元素是地址，又可以指向⼀块区域。

图解过程：

上面的代码是正确的，但是我们在实际使用的时候很少会这样用。事实上，我们更多时候用指针数组来模拟二维数组。

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

指针数组模拟二维数组是什么意思呢？
按照惯例，还是为大家先介绍一段代码：

#define _CRT_SECURE_NO_ARNINGS
#include <stdio.h>

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5 };
	int arr2[] = { 1, 2, 3, 4, 5 };
	int arr3[] = { 1, 2, 3, 4, 5 };
	int * parr[3] = { arr1, arr2, arr3 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", parr[i][j]);
			//parr[i] == *(parr+i)
			//parr[i][j] == *(*(parr+i)+j)
		}
		printf("\n");
	}
	return 0;
}

图解过程：

运行结果：

parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型⼀维数组，parr[i][j]就是整型⼀维数组中的元素。
我们用上述代码模拟实现了⼆维数组的效果，但事实上并非完全是⼆维数组，因为每一行数据在内存中并不是连续存放的。
好了，以上就是本期博客的全部内容了，喜欢的小伙伴不要忘记点赞哟。也欢迎大家在评论区留言讨论，我们下期再见。