这一讲讲的是指针与数组之间的关系

1.对于数组名的理解

先说明结论：数组名就是数组首元素的地址，但是在使用sizeof数组名和&数组名时是个例外

1.1验证数组名就是数组首元素的地址

对于上面的代码，结果如下：

可以看出&arr[0]的结果和arr的地址相同，其实&arr[0]和arr的效果是相同的

1.2sizeof数组名和&数组名

结论：sizeof数组名和&数组名都是针对整个数组进行处理的

1.2.1sizeof数组名

在x64的环境下，一个int类型的整形占4个字节，所以用sizeof计算得到的结果为4 * 9 = 36，此时，就不难发现：sizeof数组名计算的是整个数组的大小，单位是字节

1.2.2&数组名

上述代码的结果为：

我们可以发现，在x86的环境下：
arr+1的地址和arr的地址相差4
&arr+1的地址和&arr的地址相差8C - 68 = 24，这个24指的是十六进制，转换成十进制就是36，而这个数组的大小刚好就是36，所以我们可以知道：这里的数组名表示的是整个数组，取出的是整个数组的地址，其实它就相当于int (*arr)[9]

2.使用指针访问数组

结论：
p[i] == (p+i)
数组元素在进行访问时，即使以p[i]形式写入，编译器在进行编译时，也会将p[i]形式转换成(p+i)形式进行访问的

使用指针访问数组的使用：

//2.使用指针访问数组
int main()
{
	int arr[9] = { 0 };

	int i = 0;

	//对数组元素进行输入
	for (i = 0; i < 9; i++)
	{
		//scanf("%d", &arr[i]);  //这个写法和下面的写法的作用是相同的
		scanf("%d", arr+i);
	}

	//对数组元素进行打印
	for (i = 0; i < 9; i++)
	{
		//printf("%d ", arr[i]);  //这个写法和下面的写法的作用是相同的
		printf("%d ", *(arr + i));
	}
	return 0;
}

3.数组传参的本质

总结：
数组传参的本质是传入了数组首元素的地址

这串代码的结果为：

结果呈现的原因如下：数组传参的本质是传入了数组首元素的地址，而在X86的环境下，一个指针类型的变量的大小为4个字节，也就是说sizeof(arr) = 4，而sizeof(arr[0])的大小为一个整形的大小，也是4，所以两个值相比就是1

4.冒泡排序

冒泡排序的核心思想:相邻两个元素进行比较

//冒泡排序（进行逆序排序）

//方法1
void BubbleSort1(int* pa, int sz)                 //这个冒泡排序会稍微浪费时间，因为不管数组是怎么样的数组
{                                                //这个冒泡排序都会进行大小比较，如果这个数组一开始已经是
	int count = 0;                               //我们需要的数组的话，还是会进行排序
	for (int i = 0; i < sz - 1; i++)             //此时count恒等于45
	{
		for (int j = 0; j < sz - 1 - i; j++)
		{
			if (*(pa + j) < *(pa + j + 1))
			{
				int temp = *(pa+j);
				*(pa + j) = *(pa + j + 1);
				*(pa + j + 1) = temp;
			}
			count++;
		}
	}
	printf("%d\n", count);
}


//优化
void BubbleSort(int* pa, int sz)                 
{                                                
	int flag = 1; //假设一开始就是需要的数组
	int count = 0;
	for (int i = 0; i < sz - 1; i++)             
	{
		for (int j = 0; j < sz - 1 - i; j++)
		{
			if (*(pa + j) < *(pa + j + 1))
			{
				flag = 0; //如果进行排序了的话，flag就变成0，认为还需要排序
				int temp = *(pa + j);
				*(pa + j) = *(pa + j + 1);
				*(pa + j + 1) = temp;
			}
			count++;      //这时count应该小于等于45
		}
		if (flag)  //如果一轮排序进行完，没有进行排序动作，就说明这个数组就是一开始需要的数组
			break; //所以就不用再次排序
		flag = 1; //排序进行一组，再次认为这个数组已经排序好了
	}
	printf("%d\n", count);
}


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

	int sz = sizeof(arr) / sizeof(arr[0]);

	//冒泡排序
	BubbleSort(arr, sz);

	//打印
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

5.二级指针

指针变量也是变量，那么指针变量的地址就可以用二级指针来存储，关系如图所示：

对于二级指针的运算有：

int main()
{
	int a = 0;
	int* pa = &a;
	int** ppa = &pa;


	int b = 10;
	*ppa = &b; //*ppa得到的是pa
	           //相当于pa = &b
	**ppa = 30;//等价于*pa = 30，也就是b = 30
	return 0;
}

6.指针数组

总结：
类比于整型数组（存放整形的数组）、字符数组（存放字符的数组）
指针数组就是存放指针的数组，本质上还是数组

指针数组的每个元素都是指针，也可以指向一片区域

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

//指针数组模拟二维数组
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };

	int* arr[] = { arr1, arr2, arr3 };  //使用arr数组存放上面三个数组的首元素地址

	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);  //此时的arr[i]代表访问arr[]数组的元素arr[i]指向了整形的一维数组
		}                              //arr[i][j]就表示一维数组中的元素
		printf("\n");      //但是这个方法并不是真正的二维数组，因为每一行并不是连续存储的
	}
	return 0;
}