深入理解指针：【探索指针的高级概念和应用二】

目录

一，数组参数、指针参数

1.一维数组传参

2.二维数组传参

3.一级指针传参

4.二级指针传参

二，函数指针

三，函数指针数组

🍂函数指针数组的用途（转移表）： 

四，指向函数指针数组的指针

---

一，数组参数、指针参数

我们在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？下面我们就一起来探究一下。

1.一维数组传参

#include <stdio.h>
//数组传参，形参是可以写成数组形式的，因为这儿传参的本质是数组首元素的地址，所以大小可以不写
void test(int arr[])
{}//这儿不会去创建一个新的数组，这个大小是无意义的，所以数组里边的大小也可以省略
void test(int arr[10])
{}//数组传参的本质是传递数组首元素的地址；数组传参，形参也可以是指针
void test(int* arr)
{}//数组传参，形参用数组形式，数组的大小也可以省略
void test2(int* arr2[20])
{}//arr2的每个元素类型都是int*，这儿传过来的是首元素地址，即第一个元素的地址（int*的地址），
//所以就是将一级指针的地址取出来放在二级指针里边去
void test2(int** arr2)
{}int main()
{int arr[10] = { 0 };//定义了一个一维数组，数组里边有10个元素，每个元素是int类型int* arr2[20] = { 0 };//数组里边有20个元素，每个元素是int*类型test(arr);test2(arr2);
}

2.二维数组传参

//数组传参，形参的部分写成数组
void test(int arr[3][5])
{}//错误写法
//数组传参的时候，行可以省略，但是列绝对不能省略
void test(int arr[][])
{}//正确写法
void test(int arr[][5])
{}//错误写法
//数组名表示首元素的地址，即第一行的地址；而这是一个整型指针，
//整型指针是用来接受整型变量的地址的，所以这种写法是错误的
void test(int* arr)
{}//错误写法
//二维数组传过来拿指针数组接收了，应该用数组指针接收
void test(int* arr[5])
{}//正确写法
//这是一个数组指针，指向5个元素，每个元素是int类型，它可以指向数组中的第一、二、三行
void test(int(*arr)[5])
{}//错误写法
//二级指针是用来接收一级指针的地址的
void test(int** arr)
{}int main()
{int arr[3][5] = { 0 };//定义了一个三行五列的二维数组test(arr);//对数组进行传参
}

🍂总结：

二维数组传参，函数形参的设计只能省略第一个[ ]的数字。因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素，这样才方便运算。

3.一级指针传参

#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;//将数组的数组名赋给了p，本质是将数组首元素的地址赋给了pint sz = sizeof(arr) / sizeof(arr[0]);print(p, sz);//一级指针p，传给函数return 0;
}

🌴我们可以思考一下当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

void test(int* p)
{}int a = 10;test(&a);//传整型变量的地址int* ptr = &a;
test(ptr);//传整型指针int arr[5];
test(arr);//传整型一维数组的数组名

4.二级指针传参

#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);//把pp这个二级指针传给test函数test(&p);//p是一级指针变量，&p也是二级指针return 0;
}

🌴我们再思考一下当一个函数的参数部分为二级指针的时候，函数能接收什么参数？ 

void test(int** p)
{}int main()
{int n = 10;int* p = &n;int** pp = &p;int* arr[6];test(&p);test(pp);test(arr);//数组名表示首元素的地址，就是int*的地址，传参后要用二级指针来接收return 0;
}

二，函数指针

我们知道数组指针是指向数组的指针，存放的是数组的地址，&数组名就是数组的地址；

那函数指针就是指向函数的指针，存放的是函数的地址，那怎么才能得到函数的地址呢？是不是&函数名呢？接下来我们通过一段代码来探究一下函数指针的神秘面纱：

int Add(int x, int y)
{return x + y;
}
int main()
{//&函数名就是函数的地址//函数名也是函数的地址printf("%p\n", &Add);printf("%p\n", Add);return 0;
}

🎈输出结果： 

我们可以看到输出的是两个相同的地址，而这两个地址都是Add函数的地址 ，所以&函数名和函数名都能得到函数的地址。那我们的函数想要保存起来，该怎么做呢？看代码：

int Add(int x, int y)
{return x + y;
}
int main()
{int (*pf1)(int, int) = &Add;//pf1就是函数指针变量int ret = (*pf1)(3, 5);//通过函数指针变量找到函数地址并且调用它printf("%d\n", ret);return 0;
}

上面代码中的pf1是函数指针变量，它可以将我们的函数保存起来，pf1先和*结合，说明pf1是指针，指针指向的是一个函数，指向的函数有两个int类型的参数，返回值类型为int类型。

---

🍂 接下来我们再阅读两段有趣的代码（出自：《C陷阱和缺陷》）：

🍃代码一：

int main()
{( *(void (*)())0 )();return 0;
}

在上面这段代码中我们从最熟悉的0开始下手，0是个数字；0前面的void (*)()这部分是指针指向了一个函数，函数没有参数，返回类型是void，所以这部分是一个函数指针类型；将类型放在括号里边就是要强制类型转换，转换完后前面加个*，就是要解引用，去调用这个函数，调用的这个函数也没有参数；

总结起来就是上面这段代码是在调用0地址处的函数，这个函数没有参数，返回类型是void。

🍃代码二：

int main()
{void (*signal(int, void(*)(int)))(int);return 0;
}

 上面这段代码比较复杂，我们可以将它简化为以下两部分

void (*  )(int);signal(int, void(*)(int));

现在我们再来看这段代码就比较好分析了，首先它是一次函数声明，声明的是signal函数，signal 函数的参数有两个，第一个是int 类型，第二个是函数指针类型，该类型是void (*)(int)，该函数指针指向的函数，参数是int，返回类型是void；signal函数的返回类型也是函数指针类型，该类型是void (*)(int)，该函数指针指向的函数，参数是int，返回类型是void。

三，函数指针数组

通过前面的学习我们知道数组是一个存放相同类型数据的存储空间，例如指针数组：

int* arr[10];

 这是一个整型指针数组，存放的是整型指针，数组的每个元素是int*。

由上边的例子我们就可以知道函数指针数组也是一个数组，它存放的是函数指针（即函数的地址 ）：

int (*parr1[10])();
//parr1 先和 [] 结合，说明 parr1是数组，
//数组的内容是int (*)() 类型的函数指针

---

🍂函数指针数组的用途（转移表）： 

🌴例子（计算器）：

void menu()
{printf("************************\n");printf("***  1.Add    2.Sub  ***\n");printf("***  3.Mul    4.Div  ***\n");printf("***  0.exit          ***\n");printf("************************\n");
}int Add(int x, int y)
{return x + y;
}
int Sub(int x, int y)
{return x - y;
}
int Mul(int x, int y)
{return x * y;
}
int Div(int x, int y)
{return x / y;
}int main()
{int input = 0;int x = 0;int y = 0;int ret = 0;do{menu();printf("请选择:> ");scanf("%d", &input);switch (input){case 1:printf("请输入操作数：");scanf("%d%d", &x, &y);ret = Add(x, y);printf("ret= %d\n", ret);break;case 2:printf("请输入操作数：");scanf("%d%d", &x, &y);ret = Sub(x, y);printf("ret= %d\n", ret);break;case 3:printf("请输入操作数：");scanf("%d%d", &x, &y);ret = Mul(x, y);printf("ret= %d\n", ret);break;case 4:printf("请输入操作数：");scanf("%d%d", &x, &y);ret = Div(x, y);printf("ret= %d\n", ret);break;case 0:printf("退出计算机\n");break;default:printf("选择错误，请重新选择\n");break;}} while (input);return 0;
}

• 上面这段代码现在只具有加减乘除的功能，但是如果我想让它实现 a&&b、a||b、a&b、a|b、a>>b、a<<b等功能时，我们的运算会越来越多，菜单里边的功能相应的也会越来越多，同时类似加减乘除的函数也会越来越多，而且switch语句会越来越长，代码会冗余。
• 那有没有什么办法让函数变得简洁呢，其实是有的。通过观察，会发现这些函数除了函数名和里边的计算不一样外，函数的参数都是两个int，返回类型都是int，所以我们可以通过函数指针数组来改写它。

🌴使用函数指针数组的实现：

void menu()
{printf("************************\n");printf("***  1.Add    2.Sub  ***\n");printf("***  3.Mul    4.Div  ***\n");printf("***  0.exit          ***\n");printf("************************\n");
}int Add(int x, int y)
{return x + y;
}
int Sub(int x, int y)
{return x - y;
}
int Mul(int x, int y)
{return x * y;
}
int Div(int x, int y)
{return x / y;
}int main()
{int input = 0;int x = 0;int y = 0;int ret = 0;do{menu();printf("请选择:> ");scanf("%d", &input);//函数指针数组 - 转移表int (*pfarr[5])(int, int) = { NULL,Add,Sub,Mul,Div };//放个NULL的原因是将这些操作函数的下标往右挤一位if (0 == input){printf("退出计算器\n");}else if (input >= 1 && input <= 4){printf("请输入操作数:>");scanf("%d%d", &x, &y);ret = (pfarr[input])(x, y);printf("ret= %d\n", ret);}else{printf("选择错误，请重新选择！\n");}} while (input);return 0;
}

四，指向函数指针数组的指针

🎈我们先来看一下整型指针数组：

int a = 10;
int b = 20;
int c = 30;//整型指针数组，数组的每个元素是int*类型
int* arr[] = { &a, &b, &c };//p是指针，是指向整型指针数组的指针
int* (*p)[3] = &arr;

有了上面的例子我们再来看指向函数指针数组的指针：

指向函数指针数组的指针是一个 指针
指针指向一个 数组 ，数组的元素都是 函数指针

void test(const char* str)
{printf("%s\n", str);
}
int main()
{//函数指针pfunvoid (*pfun)(const char*) = test;//函数指针的数组pfunArrvoid (*pfunArr[5])(const char* str);pfunArr[0] = test;//指向函数指针数组pfunArr的指针ppfunArrvoid (*(*ppfunArr)[5])(const char*) = &pfunArr;return 0;
}