深入学习指针（2）

数组名的理解

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

由此可知：数组名就是数组首元素(第一个元素)的地址。
数组名就是数组⾸元素(第⼀个元素)的地址是对的，但是有两个例外：

• sizeof(数组名)，sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的⼤⼩，
  单位是字节
• &数组名，数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首元素
  的地址是有区别的）
  除此之外，任何地方使用数组名，数组名都表示首元素的地址。

使用指针访问数组

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

一维数组传参的本质

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

由此可知：数组传参的时候，传递的是数组名，也就是说本质上数组传参本质上传递的是数组首元素的地址。
⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式：

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

冒泡排序

思路：假设需要进行升序的冒泡排序，arr[10]={3,1,7,5,8,9,0,2,4,6}，共有10个数字，在第一趟排序中需要进行9次比较，最后将最大的数字放在最后一位，第二次只需进行8次比较即可，将第二大的数放在倒数第二位……直到第九次排序将最小的一位放在第一位结束排序。由此我们可以得到代码：

void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
	int i = 0;
	for (i = 0; i<sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j<sz - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
//指针
void bubble_sort(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i<sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j<sz - i - 1; j++)
		{
			if (*(arr + j) > *(arr+j + 1))
			{
				int tmp = *(arr+j);
				*(arr+j) =*(arr+j + 1);
				*(arr+j + 1) = tmp;
			}
		}
	}
}

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

我们还可以进行优化，因为不一定需要进行全部的排序过程，可能经过一次排序之后，排序就已经完成了，由此我们可以得到以下代码：

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

二级指针

存放指针变量地址的指针。例如：

#include<stdio.h>

int main()
{
	int a=30;
	int* b=&a;
	int** c=&b;
	printf("%d\n",**c)；//利用二级指针打印a的值
	return 0;
}

指针数组

存放指针的数组。

int* arr[10]={0};

指针数组模拟二维数组

思路：把二维数组看成是多个一维数组，再进行打印即可，由此得到以下代码：

#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 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}
	return 0;
}