⽬录

1. 数组名的理解

2. 使⽤指针访问数组

3. ⼀维数组传参的本质

4. 冒泡排序

5. ⼆级指针

6. 指针数组

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

正文开始：

1.数组名的理解

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

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

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

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
//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 <stdio.h>
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 <stdio.h>
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 <stdio.h>
int main()
{int a = 10;int* p = &a;//p是一级指针int** pp = &p;//pp是二级指针return 0;
}

 6. 指针数组

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

 

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

 

 

#define _CRT_SECURE_NO_WARNINGS
#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* 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)

完！！！