大家好，我是深鱼~
【前言】：
指针的主题，在初阶指针章节已经接触过了，我们知道了指针的概念：
1.指针就是个变量，用来存放地址，地址的唯一标识一块内存空间（指针变量），内存单元是由编号的，编号==地址==指针
2.指针/地址/指针变量的大小是固定的4/8个字节（32位平台/64位平台）
3.指针是有类型的，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限
4.指针的运算
一、字符指针
一般使用：
cpp
#include<stdio.h>
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'w';
return 0;
}还有一种使用方式如下：
cpp
#include<stdio.h>
int main()
{
char ch = 'w';
char* p = "abcdef";
//[abcdef\0]
//char arr[]="abcdef"
printf("%s\n,p);//打印的是整个字符串
printf("%c\n,*p);//打印的是a
printf("%c\n", "abcdef"[3]);//打印的是d
return 0;
}这里的字符串"abcdef"类似于数组，把这个字符串赋给p指针，也就是字符串的首地址赋给p指针
（假设是 32位平台，指针的大小也就是4个字节，但是这个字符串却有7个字节（算上\0),这样看是放不下的）
但是这个代码存在问题，p变量赋给了常量字符串，如果改变p变量，常量字符串是不会更改的
eg：这样代码很容易出错误，所以一般会在char *p之前写上const
char* p = "abcdef";
*p = 'e';
更加安全的写法：
const char* p = "abcdef";
下面再来看一道**【经典面试题】**：
这道题的输出结果是啥？
cpp
#include <stdio.h>
int main()
{
char str1[] = "hello bit.";
char str2[] = "hello bit.";
const char *str3 = "hello bit.";
const char *str4 = "hello bit.";
if(str1 ==str2)
printf("str1 and str2 are same\n");
else
printf("str1 and str2 are not same\n");
if(str3 ==str4)
printf("str3 and str4 are same\n");
else
printf("str3 and str4 are not same\n");
return 0;
}【答案】：
str1 and str2 are not same
str3 and str4 are same
【解释】：
(1)首先创建两个数组，分别放入hello bit，因为是两个不同的数组，那么字符串就存在不同的位置，当判断str1和str2，也就是两个数组的首地址的时候，这两个h地址肯定不相同
(2)str3和str4指针都指向常量字符串，因为常量字符串不可修改，那么其实也没有必要再创建一个空间来存两个相同的常量字符串，如果两个指针同时指向这个常量字符串的时候，其实指向的也就是同一个地址，那么str3和str4也就相同
**【拓展】：**再加一个
if(&str3==&str4)
printf("YES\n");
else
printf("NO\n");
**【答案】：**NO
**【图解】：**指针变量不同，地址不同
p（指针变量）：表示指针变量指向的内存地址
&p ：取指针p的地址，表示编译器为变量p分配的内存地址（不同变量分配的地址不同），而不是这个指针p指向的地址
二、指针数组
指针数组是数组
字符数组-存放字符的数组
整形数组-存放整形的数组
指针数组-存放指针的数组，存放在数组的元素都是指针类型的
eg： int *arr[5]; //存放整形指针的数组
char * ch[6]; //存放字符指针的数组
【那指针数组一般怎么用呢？】
一般不会像这样使用：int *arr[3]={&a，&b，&c}
而是这样使用：可以用指针数组模拟一个二维数组
cpp
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
//int* int* int*
//指针数组
int* arr[] = { arr1,arr2,arr3 };
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
return 0;
}【图解】：指针数组放入三个数组，这三个数组的类型是int *指针类型，通过指针数组的打印可以模拟二维数组
【程序结果】：
再举个栗子：建立一个字符类型（int *）指针数组，并打印数组内的元素
cpp
#include<stdio.h>
int main()
{
char* arr[5] = { "hello bit","hehe","penggeC","bitejiuyeke","C++" };
for (int i = 0; i < 5; i++)
{
printf("%s\n", arr[i]);
}
return 0;
}【图解】：分别把字符串的首元素地址传给了指针，然后把这些指针放在数组中
【程序结果】：
三、数组指针
3.1数组指针的定义
数组指针是指针，类型于字符指针（指向字符的指针），整形指针（指向整形的指针），浮点型指针（指向浮点型的指针），那么数组指针就是指向数组的指针
int a=10; int *p=&a;(整形指针）
char ch='a'; char *pc=&ch;（字符指针）
int arr[10]; int (*p)[10]=&arr;（数组指针）
下面我们来理解一下int（*p）[10]：
int (*p) [10]中的*表示p是一个指针，*p指向[10]表示指向数组的指针，int代表数组元素类型
3.2&数组名vs数组名
首先数组名的理解：
数组名是首元素的地址但是存在两个例外：
1.sizeof（数组名），这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
2.&数组名，这里的数组名表示整个数组，取出来的是数组的地址
cpp
int main()
{
int arr[10];
printf("%p\n", arr);//int *
printf("%p\n", arr+1);
printf("%p\n", &arr[0]);//int *
printf("%p\n", &arr[0]+1);
printf("%p\n", &arr);//int *[10]这就是数组指针的类型
printf("%p\n", &arr+1);
//指针类型决定了指针+1到底+几个字节
return 0【注意】：这里的10不可省略，数组指针要明确指针指向的数组是几个元素
【练习】：
char* arr2[5]的数组指针：char* （*p）[5]（前面的char*是数组类型）
int arr3[]={1,2,3}的数组指针：int (*p）[3] (数组指针要明确指向数组的大小，这个3必须写）
3.3数组指针的使用
先来看看用数组指针打印数组元素：这其实是多此一举的，本来可以直接arr打印数组元素，但是还要定义一个数组指针，再用数组指针来打印数组元素
cpp
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9 };
int(*p)[10] = &arr;
for (int i = 0; i < 10; i++)
{
printf("%d ", (*p)[i]);
}
return 0;
}【那如果把打印的内容换成p[i]，结果又如何呢？】
p[i]等价于*（p+i），而指针+1，直接就跳过一个数组地址，根本不可能打印出数组的元素
直接把数组名传给p指针，这样才能访问数组的元素：int *p=arr
代码运行结果:
【那么数组指针到底有什么用呢？】
数组指针用都是用在二维数组上，我们来看一个例子：打印一个二维数组
正常的方法：形参使用二维数组的形式
cpp
#include<stdio.h>
void print(int arr[3][5], int row, int col)
{
for (int i = 0; i < 3;i++)
{
for (int j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
print(arr, 3, 5);
return 0;
}数组指针的方法：形参使用数组指针的形式
（1）首先数组名是首元素的地址，在二维数组中，首元素的地址就是第一行数组元素的地址
（2）形参**int （*p）[5]**代表：这个数组指针指向的是数组第一行5个元素的地址
（3）**p[i][j]**代表：p[i]就相当于*（p+i），每行的地址，解引用后就是每行的数组名，每行的数组名[j],就可以得到每行的数组元素
cpp
#include<stdio.h>
void print(int (*p)[5], int row, int col)
{
for (int i = 0; i < 3;i++)
{
for (int j = 0; j < 5; j++)
{
printf("%d ", p[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
print(arr, 3, 5);
return 0;
}学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：
cpp
int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];<1>arr是一个能够存放5个整形数据的数组
<2>parr1是一个数组，数组10个元素，，每个元素的类型都是int *
<3>parr2是一个指针，该指针是指向数组的，指向的数组有10个元素，每个元素的类型都是int
<4>parr3是一个数组，是存放数组指针的数组（这个parr3【10】数组10个元素），存放数组指针（int (* ) [5]，指向的数组有5个元素，每个元素是int类型（这个比较难，不理解也没事）
对于4画图理解：parr3是10个元素的数组，每个元素中都是地址（数组指针），每个元素的类型都是int（* ）[5],而对应数组中存放的数组指针，这个指针指向5个元素的数组
四、数组参数，指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数应该如何设计呢？
4.1一维数组传参
数组传参，形参是可以写成数组的形式的，也可以是指针，传参的本质是传递了数组首元素的地址
以下6种方式传参都是可以的
cpp
#include <stdio.h>
void test(int arr[])//ok，数组的形式传参，可以省略数组的元素个数
{}
void test(int arr[10])//ok，直接把数组拿过来，数组的形式传参
{}
void test(int* arr)//ok，指针的形式传参
{}
void test2(int* arr[20])//ok，直接把指针数组拿过来，数组的形式传参
{}
void test2(int* arr[])//ok，数组的形式传参，可以省略数组的元素个数
{}
void test2(int** arr)//ok，指针的形式传参
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };//指针数组
test(arr);
test2(arr2);
}对于最后一种的理解：arr2每个元素的类型都是int *，arr2也就是取int *元素的首地址，一个指针的地址，那么就放到二级指针里面去
4.2二维数组传参
cpp
void test(int arr[3][5])//ok
{}
void test(int arr[][])//no，二维数组只能省略行，不可省略列
{}
void test(int arr[][5])//ok
{}
void test(int* arr)//no，二维数组首元素地址是第一行的地址，所以指针传参不能省略列
{}
void test(int* arr[5])//no，这是一个指针数组，而不是本来的二维数组
{}
void test(int(*arr)[5])//ok，数组指针，指针指向数组，数组中有5个元素
{}
void test(int** arr)//no，二级指针是用来接收一级指针的地址，而我们只需要第一行数组的地址，一级指针即可
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
}二维数组传参：
<1>数组形式传参：只能省略行，不可省略列
<2>指针形式传参：参数形式应该是数组指针int （*arr）【列】，而不能是指针数组
4.3一级指针传参
cpp
#include <stdio.h>
void print(int *p, int sz)
{
int i = 0;
for(i=0; i<sz; i++)
{
printf("%d\n", *(p+i));
}
}
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9};
int *p = arr;
int sz = sizeof(arr)/sizeof(arr[0]);
//一级指针p，传给函数
print(p, sz);
return 0;
}一级指针传参形式参数写成一级指针就可以
【思考】：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
（1）传一维数组的数组名
（2）传变量的地址
（3）传指针
4.4二级指针传参
cpp
#include <stdio.h>
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int*p = &n;
int **pp = &p;
test(pp);
test(&p);
return 0;
}二级指针传参形式参数写成二级指针或者一级指针的地址都可以
【思考】：
当函数的参数为二级指针的时候，可以接收什么参数？
(1)一级指针的地址
(2)二级指针
(3)传指针数组（首元素的地址）
五、函数指针
类比：
数组指针-指向数组的指针-存放的是数组的地址-&数组名就是数组的地址
函数指针-指向函数的指针-存放的是函数的地址-那么怎么得到函数的地址呢
cpp
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
//&函数名就是函数的地址
//函数名也是函数的地址
printf("%p\n", &Add);
printf("%p\n", Add);
int (*pf1)(int, int) = Add;//pf1就是函数指针变量
int (*pf2)(int, int) = &Add;
return 0;
}&函数名就是函数的地址，函数名也是函数的地址
int (*pf1)(int, int) = Add这里的括号不可省略，不然前面的部分就跟函数声明一样
利用函数指针进行Add加和：
cpp
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf2)(int, int) = &Add;
//int (*pf2)(int, int) = Add;这样写也可以
int ret = (*pf2)(2, 3);
//int ret = pf2(2, 3);不用*也可以，但是用了*一定得加括号
//int ret = *pf2(2, 3);这个就相当于*5
printf("%d\n", ret);
return 0;
}阅读两段有趣的代码：
(*( void ( * )( ) ) 0 )( ) ;
（1）void（*）（）是函数指针类型
（2）（类型）常量-强制类型转换-eg：int a=(int )3.14
（3）有颜色的就是将0强制类型转换为函数指针类型，这个0就变成了地址（地址），然后调用0地址处的函数，这个函数没有参数，返回值是void
void ( * signal ( int , void(*)(int) ) )( int );
这个代码是函数声明，声明的是signal函数，signal函数的参数有2个
一个是int 类型
一个是函数指针类型，该类型是void(*)(int)
该函数指针指向的函数，参数是int，返回类型是void
signal函数的返回类型也是函数指针类型，该类型是void(*)(int)
该函数指针指向的函数，参数是int，返回类型是void
【将这个代码简化】：
typedef void（*pfun_t)( int );//也就是将void(*)(int)改给名字叫pfun_t
pfun_t signal(int ,pfun_t);
本次内容就到此啦，欢迎评论区或者私信交流，觉得笔者写的还可以，或者自己有些许收获的，麻烦铁汁们动动小手，给俺来个一键三连，万分感谢 !
