指针（3）
这篇主要来讲解指针和数组之间的关系
1 .数组名的理解
数组名是数组首元素的地址
来验证一下，代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
printf("&arr[0]=%p\n", &arr[0]);
printf("arr=%p\n", arr);//为了验证数组名是否是数组首元素的地址
return 0;
}
打印结果如下：
[外链图片转存中…(img-W4kajpiI-1715165752015)]
由此可以验证数组名是数组首元素（第一个元素）的地址
PS:上图是在X64的环境下观察的，如果在X86的环境下会更容易观察
但是，有两个例外
1.sizeof(数组名)
这里的数组名表示的是整个数组，计算的是整个数组的大小，单位是字节
[外链图片转存中…(img-hLHBJTUA-1715165752017)]
2.&(数组名)
这里的数组名也表示整个数组，取出的也是整个数组的地址
除此以外，所有的数组名表示数组首元素的地址
那肯定有人好奇有什么不同呢？
且看代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
printf("&arr[0]=%p\n", &arr[0]);
printf("arr=%p\n", arr);
printf("&arr=%p\n", &arr);
return 0;
}
打印结果如下：
[外链图片转存中…(img-6qnlS8Vt-1715165752017)]
欸，怎么都是一样的呢？别着急，且听我娓娓道来
通过上一节指针的运算我们知道，因为数组在内存中是连续存放的，所以能计算跳过的字节数
代码如下：
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
printf("&arr[0]=%p\n", &arr[0]);
printf("&arr[0]+1=%p\n", &arr[0] + 1);
printf("arr=%p\n", arr);
printf("arr+1=%p\n", arr + 1);
printf("&arr=%p\n", &arr);
printf("&arr+1=%p\n", &arr + 1);
}
结果如下：
[外链图片转存中…(img-HGgi6uvL-1715165752018)]
可以很清楚的发现：前两个计算结果一模一样，由此可以证明，数组名是数组首元素的地址；
因为在内存中存储的形式是十六进制的形式，计算之后发现差40个字节，所以也能证明出**&（数组名）里面数组名表示数组整个地址**
还有个特别重要的知识点就是：指针类型决定了指针的差异
&arr[0]和arr都表示的指针类型是int*,那&arr表示的指针类型是什么呢，我们先按下不表
2 .使用指针访问数组
这样我们可以优化之前的代码
先来举个小例子：
使用下标的方式访问数组：
int main()
{
int arr[10] = { 0 };
int sz = sizeof(arr) / sizeof(arr[0]);
//输入
for (int i = 0; i <sz; i++)
{
scanf("%d", &arr[i]);
}
//输出
for (int i = 0; i <sz; i++)
{
printf("%d", arr[i]);
}
return 0;
}
打印结果为：
[外链图片转存中…(img-bC1h212F-1715165752018)]
用指针访问数组：
int main()
{
int arr[10] = { 0 };
int sz = sizeof(arr) / sizeof(arr[0]);
//输入
int i = 0;
int* p = arr;//也可以写成&arr[0]
for ( i = 0; i <sz; i++)
{
scanf("%d", p+i);//表示的是下标为i的数组元素
}
//输出
for (int i = 0; i <sz; i++)
{
printf("%d", *(p+i));//切记不可以写成*p+i,我们要拿到的是解引用里面的值
//这里也可以写成*(arr+i)
}
return 0;
}
打印结果也是相同的
1 .* (arr+i)等价于arr[i],arr的指针类型是int*,i是指它跳过的元素个数，我们也知道加法有交换律，也等价于*（i+arr),也相当于i[arr],[]此时只是一个操作符而已
2.编译器在处理arr[i]的时候会将其转化为*(arr+i)
额外补充几个点：
1.数组就是数组，是一块连续的空间，是可以存放一个或多个数组的
2.指针变量是一个变量，是可以存放地址的变量，数组和指针不是一回事，但是可以是一种指针访问数组
为什么可以使用指针来访问数组呢？
1.数组在内存中是连续存放的
2.指针的元素很方便可以遍历数组，取出数组的内容（指针运算）
3 .一维数组传参的本质
void test(int arr[10])//这里面的形参也可以写成int*arr
//当指针接受数组名的时候，指针是不特殊的，换而言之，就是在sizeof（数组名）和&（数组名）的情况也一样
{
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);//arr是数组名，数组名是数组首元素的地址，
//数组传参的本质，传递的是数组首元素的地址
//所以形参写成数组的形式，本质上也是一个指针变量
return 0;
}
运行结果为：
[外链图片转存中…(img-W6lOYSlS-1715165752018)]
4 .冒泡排序
思想：两两相邻的元素，不满足顺序就交换，满足顺序就找下一对
[外链图片转存中…(img-Tl5c6mPb-1715165752018)]
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void bubble_sort(int *arr,int sz)
{//先确定趟数
int i = 0;
for (i = 0; i < sz - 1; i++)
{//元素内部的比较
int flag = 1;
for (int j = 0; j < sz - 1 - i; 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;
}
}
}
}
void print_arr(int* arr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d\n", arr[i]);
}
}
int main()
{
//首先输入
int arr[10] = { 0 };
int sz = sizeof(arr) / sizeof(arr[0]);
//排序，写一个函数使其排位升序数组
bubble_sort(arr, sz);
print_arr(arr, sz);
return 0;
}
//在上面做出一些改进，如果一个数组已经满足顺序的话，进行运算是会效率很低的
5 .二级指针
什么是二级指针？先看一段代码：
int main()
{
int a=10;
int*pa=&a;//pa一级指针
int**ppa=&pa;//ppa二级指针
}
[外链图片转存中…(img-JYfdZc0x-1715165752019)]
- 一级指针是用来存放普通变量的地址的，二级指针是用来存放一级指针变量的地址
那来看看解引用打印的结果：
[外链图片转存中…(img-kmzZVFUv-1715165752019)]
- 这里有个等量关系：* * ppa=*pa=a
- 还有个要注意的点：二级指针和二维数组没有对应关系
6 .指针数组
指针数组究竟是指针还是数组？
先来看几个例子：
char arr[10];//字符数组，存放字符的数组
int arr[5];//整型数组，存放整型的数组
指针数组就是存放指针的数组，数组的每个元素其实是指针类型
7 .指针数组模拟二维数组
int main()
{
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 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]);//*(*（arr+i)+j)
}
printf("\n");//这是为了输出五个元素再换行
}
return 0;
}
图示如下：
[外链图片转存中…(img-tM9KLO2S-1715165752019)]
8 .字符指针变量
int main()
{
char ch = 'w';
char* p = &ch;
printf("%c\n", *p);
*p = 'm';
printf("%c\n", *p);
}
运行结果：
[外链图片转存中…(img-uAUepz3L-1715165752020)]
做个对比：
[外链图片转存中…(img-IEYPkr6Q-1715165752020)]
代码如下：
int main()
{
char* p = "abcdef";
printf("%c\n", *p);
printf("%s\n", p);//使用%s字符打印的时候只需要提供首字母的地址就好了
}
运行结果：
[外链图片转存中…(img-lw8x4LKp-1715165752020)]
那么可能会有人产生疑问：
如下：
[外链图片转存中…(img-Jcb0iHyY-1715165752020)]
这个时候就要在char*p左边加上const，const放左边，意味着不能通过指针p来改变值，直接把错误扼杀在摇篮里，如果不加const，语法上没错误，但是程序会崩溃，还需要通过调试来找错误，是非常浪费时间的
《剑指offer》中收录了⼀道和字符串相关的笔试题，我们⼀起来学习⼀下：
1#include <stdio.h>
2
3 int main()
4 {
5 char str1[] = "hello bit.";
6 char str2[] = "hello bit.";
7 const char *str3 = "hello bit.";
8 const char *str4 = "hello bit.";
9
10 if(str1 ==str2)
11 printf("str1 and str2 are same\n");
12 else
13 printf("str1 and str2 are not same\n");
14
15 if(str3 ==str4)
16 printf("str3 and str4 are same\n");
17 else
18 printf("str3 and str4 are not same\n");
19
20 return 0;
21 }
答案如下：
[外链图片转存中…(img-4Zh5Cv4m-1715165752020)]
这⾥str3和str4指向的是⼀个同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域，放到只读数据区
当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始
化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。
9 .数组指针变量
刚刚前面也提到过，指针数组——是数组，存放的是指针（地址）
还是通过类比的方法来理解：
字符指针——char*——指向字符的指针——字符指针变量存放字符变量的地址
char ch=‘w’;
char * pc=&ch;
整型指针——int*——指向整形的指针——整型指针变量存放整型变量的地址
int a=10;
int*pa=&a;
数组指针——指向数组的指针——数组指针变量存放数组的地址（&（数组名））
写一段代码来看：
int main()
{
int arr[10] = { 1,2,3,4,5 };
int(*p)[10] = &arr;//p就是数组指针，存放的数组的地址
}
下⾯代码哪个是数组指针变量？
int *p1[10];//p1和[10]结合，有10个元素，每个元素是int*,它是存放指针的数组，叫指针数组
int (*p2)[10];//p2和指针结合，是指针，然后指向int，每个元素int，是数组指针
数组指针类型解析：
1int (*p) [10] = &arr;
2 | | |
3 | | |
4 | | p指向数组的元素个数
5 | p是数组指针变量名
6 p指向的数组的元素类型
再来看一个：
char* arr[5];
char*(*pc)[5]=&ch;
址（&（数组名））
写一段代码来看：
int main()
{
int arr[10] = { 1,2,3,4,5 };
int(*p)[10] = &arr;//p就是数组指针，存放的数组的地址
}
下⾯代码哪个是数组指针变量？
int *p1[10];//p1和[10]结合，有10个元素，每个元素是int*,它是存放指针的数组，叫指针数组
int (*p2)[10];//p2和指针结合，是指针，然后指向int，每个元素int，是数组指针
数组指针类型解析：
1int (*p) [10] = &arr;
2 | | |
3 | | |
4 | | p指向数组的元素个数
5 | p是数组指针变量名
6 p指向的数组的元素类型
再来看一个：
char* arr[5];
char*(*pc)[5]=&ch;
pc前面的*表明的是指针，有五个元素，类型是char *