深⼊理解指针1（指针和数组）

⽬录

1. 数组名的理解

2. 使⽤指针访问数组

3. ⼀维数组传参的本质

4. 冒泡排序

5. ⼆级指针

6. 指针数组

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

正文开始：

1.数组名的理解

首先我们已经知道应该如何用指针来访问数组

#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int arr[10] = { 0 };
	int* p = &arr[0];
	return 0;
}

这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且是数组⾸元素的地址 

#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int arr[10] = { 0 };
	int* p = &arr[0];
	printf("arr[0] = %p\n", &arr[0]);
	printf("arr    = %p\n", arr);
	return 0;
}

 我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址

那么这里就会产生一个疑问：

如果arr是数组⾸元素的地址，那输出应该的应该是4/8才对，这里为什么会打印40？

这里是因为有两个特殊情况：

• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩，单位是字节

• &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的） 

这里打印出的三个地址都是一样的，那么我们进一步探究一下： 

  这里我们发现&arr[0]和arr都只跳过了一个·字节，而&arr代表的是整个数组的地址，+1会跳过整个数组

2. 使⽤指针访问数组

接下来我们会实现用指针来访问数组

#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0;i < sz;i++)
	{
		scanf("%d", p + i);
	}
	for (i = 0;i < sz;i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

另外因为arr和p装的都是数组首元素地址，所以我们把p换成arr也可以

#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0;i < sz;i++)
	{
		scanf("%d", arr + i);
	}
	for (i = 0;i < sz;i++)
	{
		printf("%d ", *(arr + i));
	}
	return 0;
}

同样我们换成p[i]也可以正产打印

#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0;i < sz;i++)
	{
		scanf("%d", arr + i);
	}
	for (i = 0;i < sz;i++)
	{
		printf("%d ", p[i]);
	}
	return 0;
}

综上，我们可以得到四种写法

p[i] = arr[i] = *(p+i) = *(arr+i) 

拓展：

根据加法之间的交换律，我们可以把 *(arr+i) 写成 *(arr+i) ，因此我们就可以吧arr[i]写成i[arr]，虽然看起来有些奇怪，但同样可以得到正确的编译结果

这种方法可行，但是不推荐

所以本质上p[i] 是等价于 *(p+i)。同理arr[i] 应该等价于 *(arr+i)，数组元素的访问在编译器处理的时候，也是转换成⾸元素的地址+偏移量求出元素的地址，然后解引⽤来访问的。

注意：

1.数组就是数组是一块连续的空间（）

2.指针（变量）就是指针（变量），大小为4字节或者8字节

3.数组名是地址，是首元素的地址

4.可以用指针来访问数组

3. ⼀维数组传参的本质.

#define _CRT_SECURE_NO_WARNINGS
#include 
void Print(int arr[10], int sz)
{
	int i = 0;
	for (i = 0;i < sz;i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Print(arr, sz);
	return 0;
}

这是我们之前数组传参来打印数组的写法，但是我们来看下一种写法

#define _CRT_SECURE_NO_WARNINGS
#include 
void Print(int arr[10])
{
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0;i < sz;i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	Print(arr);
	return 0;
}

结果显示是错误的，这是为什么呢？

其实我们知道数组在传参时传递的是数组名arr，也就是数组首元素的地址，所以在进行sizeof（arr）计算时计算的是⼀个地址的⼤⼩（单位字节）⽽不是数组的⼤⼩（单位字节），正是因为函数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

既然传递的时数组首元素地址是我们就也可以采用指针来接收。

#define _CRT_SECURE_NO_WARNINGS
#include 
//void Print(int arr[10])
//{
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int i = 0;
//	for (i = 0;i < sz;i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}
void Print(int* arr, int sz)
{
	int i = 0;
	for (i = 0;i < sz;i++)
	{
		printf("%d ", *(arr + i));
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Print(arr, sz);
	return 0;
}

所以我们可以得到一个结论：

1.数组传参的本质是传递了数组首元素地址的，所以形参访问的数组是和实参的数组是一样的

2.形参的数组是不会再单独创建空间的，所以形参的数组是可以省略大小的

4. 冒泡排序

冒泡排序的核⼼思想就是：两两相邻的元素进⾏⽐较

#define _CRT_SECURE_NO_WARNINGS
#include 
void bubble_sort(int arr[10], 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,0 };
	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;
}

优化：

#define _CRT_SECURE_NO_WARNINGS
#include 
void bubble_sort(int arr[10], int sz)
{
	int i = 0;
	//趟数
	for (i = 0;i < sz - 1;i++)
	{
		int j = 0;
		//假设已经有序了
		 int flag = 1;
		//每一趟比较多少次
		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;
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}
int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	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;
}

 5. ⼆级指针

#define _CRT_SECURE_NO_WARNINGS
#include 
int main()
{
	int a = 10;
	int* p = &a;//p是一级指针
	int** pp = &p;//pp是二级指针
	return 0;
}

 6. 指针数组

首先我们要知道指针数组是数组，整形数组存放的整形，字符数组存放的是字符，那么指针数组存放的就是指针

 

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

 

 

#define _CRT_SECURE_NO_WARNINGS
#include 
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[i] = *(arr+i)

arr[j] = *(arr+j)

完！！！