C语言之指针（2）

1.数组名的理解：首先测试一下数组名是否为首元素地址：

int main()
{
	int arr[] = { 1,2,3,4,5 };
	printf("&arr    =%p\n", arr);
	printf("&arr[0] =%p\n", &arr[0]);

	return 0;
}

这两个是一样的，所以数组名就是首元素地址。那么问题来了，既然数组名是首元素的地址，那么sizeof（arr）的值应该是地址大小为4或者8个字节，在x86环境下应该是4个字节的 ，

int main()
{
	int arr[] = { 1,2,3,4,5 };
	printf("&arr    =%p\n", arr);
	printf("&arr[0] =%p\n", &arr[0]);

	printf("%d\n", sizeof(arr));
	return 0;
}

结果：

出问题了，所以数组名是首元素地址这个说法应该还是有问题的。

事实是，数组名确实是首元素地址，但是有两个例外：

*sizeof（数组名）中单独放数组名，这里数组名表示整个数组，计算的是整个数组的大小，单位是字节。

*&数组名，表示整个数组，取出来的是整个数组的地址

除此之外，任何地方使用数组名，数组名都表示首元素的地址。

 结果也是指向这一块。首元素的地址就是从这一块开始的，整个数组也就从这一块开始的，所以整个数组的地址也从这里开始。

那么它们的区别：

 数组名+1，70变74，加了4个字节，说明跳过了一个整型，首元素地址+1也跳过了4个字节即一个整型。第三个+1跳过了20个字节（16进制转换），说明跳过了整个数组。

因为&arr是这一个数组的地址，+1就跳过一整个数组。假如后面紧接着还有一个新数组，那么+1就跳到下一个数组去了。可以类比为你在一个数组里访问元素，+1就到下一个元素了，这里是把数组当作元素了。

2.使用指针访问数组：

int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[0];
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}

	return 0;
}

上期有讲到，这里不多做赘述，还是蛮好理解的。但是printf里面可以写成*(p+i)也可以写成arr[i]，刚刚把arr赋给了p，arr表示首元素地址，p里面存这个地址，即p也是首元素地址，那么*(p+i)能不能用arr替代？可以的。所以也可以写成*(arr+i)，那么两者是不是互通的，也就是说arr[i]也可以写成p[i]。

int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[0];
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}

	return 0;
}

 

 

所以arr[i] == *(arr+i) == *(p+i) == p[i] ，其实写成数组形式，编译器也会转换为指针形式来计算。还有一种就是由于加法交换律，*(arr+i)可以写成*(i+arr)，既然可以这样写，也可以演变写为i[arr]。

int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[0];
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", i[arr]);
	}

	return 0;
}

这个地方可以说明的是[ ]也只是一个操作符而已。

3.一维数组的传参本质：首先从一个问题开始，之前都是在函数外部计算数组元素个数的，那么把数组传给函数后，可以在函数内部求数组的元素个数吗？

void test(int arr[])
{
	int sz2= sizeof(arr) / sizeof(arr[0]);
	printf("sz2=%d\n", sz2);
}
int main()
{
	int arr[10] = { 0 };
	int sz1 = sizeof(arr) / sizeof(arr[0]);
	printf("sz1=%d\n", sz1);

	test(arr);

	return 0;
}

分析一下：传参后最后打印了1，arr[0]是四个字节，也就是说前面那个sizeof(arr)也是4个字节，也就是说这个arr不是一整个的数组了。在传参的时候传了个数组名，既没有取地址也没有单独放在sizeof内部，所以arr是数组首元素的地址，test函数内部要有个形参接受这个地址的话，那么这个形参应该是一个指针变量。形参写成数组的形式本质是一个指针变量，写成数组形式是为了方便理解。

结论：一维数组传参的时候，传过去的是数组首元素的地址。形参的部分可以写成指针的形式，也可以写成数组的形式，但本质上都是指针，写成数组形式是为了方便理解。

4.冒泡排序：两两相邻比较然后排序，然后换下一对，就比如3，2，1，先比较3和2，然后交换，再比较3和1，然后交换，最后比较2和1，然后交换完成排序。第一轮是把最大的来到最后，第二轮就把第二大的放到倒数第二位，以此类推。假如有n个数，那么要进行的轮数最大是n-1。再根据上面数组传参的知识先把元素个数在外面求好然后传参，再利用for循环来解决轮数的问题。

然后再实现内部的两两相邻元素的比较。随着轮数增加，需要比较的次数也会变少，有十个第一轮就有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-1-i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;//实现比较并交换
			}
		}
	}
}
int main()
{
	int arr[] = { 10,9,8,7,6,5,4,3,2,1 };//降序形式，实现升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

 还可以优化一下，一轮冒泡排序后，如果一对都没换，说明已经有序了，那就在函数内部，假设有序，定义一个flag=1，然后在比较内部，一旦有交换，就把flag=0，最后跳出内层循环，如果flag还是=1，就跳出循环，没有必要进行下去了。用一个count变量来检测，最后代码为：

int count = 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-1-i; j++)
		{
			count++;
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;//实现比较并交换
				flag = 0;
			}
		}
		if (flag)
		{
			break;
		}
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//降序形式，实现升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\ncount=%d", count);
	return 0;
}

为了体现优化后的优势，我把数组改为升序的

int count = 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-1-i; j++)
		{
			count++;
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;//实现比较并交换
				//flag = 0;
			}
		}
		//if (flag)
		//{
		//	break;
		//}
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };//降序形式，实现升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\ncount=%d", count);
	return 0;
}

 5.二级指针：之前学的都是一级指针，虽然一级指针里面放的是别人的地址，但是它也是一个变量，也有自己的地址，那就可以把指针变量的地址取出来，放到另外一个变量里，这个变量应该得有两颗星，就是二级指针变量，用来存放一级指针变量的地址，类型是type**。

同理也有三级指针。这种其实就是套娃啦。

6.指针数组：类比整型数组和字符数组，它们分别是用来存放整型和字符的数组，那么指针数组顾名思义就是用来存放指针的数组。写法就是type* arr[ ]，加个*就表示存放指向type类型的指针的数组。

例：利用指针数组来模拟实现二维数组：

首先分别创建3个整型数组，然后将这三个数组都存到一个指针数组里，因为数组名都表示首元素的地址，所以可以用指针数组来接收。

只要你去arr[n]就可以找到对应下标的起始地址。 然后就可以接着去访问里面的元素。那么就可以进行如下操作：

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

	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

这样子就实现了利用指针数组模拟实现二维数组了。就拿里面一个元素arr[1][1]来说，arr[1][1] 等价与 *（*（arr + 1）+ 1），

arr[1][1]：对于二维数组 arr，arr[1][1] 表示第二行（索引为1）第二列（索引为1）的元素。当使用 arr[1][1] 时，首先会找到 arr 的第二行，然后从该行中获取第二列的元素。

*( *(arr + 1) + 1)：在这里，arr + 1 首先会将指针移动到二维数组的第二行（索引为1）。接着 *(arr + 1) 将获取到第二行的首元素的地址，然后 *( *(arr + 1) + 1) 将在第二行中移动到第二列（索引为1），最终得到第二行第二列的元素。想要理解这点需要会上面的知识。

以上就是指针(2)的全部内容了。