【C进阶】之指针函数和函数指针

1 指针函数

本质是一个函数，返回类型是一个指针

格式：

​ 数据类型 * 函数名（形参列表）{

​ 函数体

​ }

2 函数指针

函数指针：本质是一个指针数据类型，函数指针指向的是一个具有相同的形参列表相同的返回类型的函数。

格式：
数据类型 函数名(形参列表) { // 函数的名字就可以表示函数的入口地址
函数体;
}

数据类型 (*函数指针变量名字)(形参列表) = 函数名;

调用函数时可以通过函数的原型直接调用，也可以通过函数指针进行调用，就将函数指针变量当成函数的名

3 回调函数

练习：使用函数指针实现计算器

#include 
#include 
#include 

int add(int a,int b){
    return a+b;
}

int sub(int a,int b){
    return a-b;
}

int mul(int a,int b){
    return a*b;
}

int divv(int a,int b){
    return a/b;
}

int calculator(int x,int y,int (*cal)(int,int)){
    return cal(x,y);
}

int main(int argc, const char *argv[])
{
    int (*result)(int,int,int (*p)(int,int))=calculator;
    printf("%d\n",result(400,200,divv));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

4 函数指针数组

函数指针数组：本质是一个数组，数组的每个成员是一个函数指针

格式：
数据类型 ( * 函数指针数组名[成员个数])(形参列表);

初始化的方式：
定义的同时进行初始化：
数据类型 (*函数指针数组名[成员个数])(形参列表) = {函数名0,函数名1,…};

先定义后初始化：
数据类型 (*函数指针数组名[成员个数])(形参列表);

函数指针数组名[0] = 函数名0;
函数指针数组名[1] = 函数名1;
函数指针数组名[2] = 函数名2;
…

访问函数指针数组中的成员：
如果有返回值： 变量名 = 函数指针数组名[index] (实参列表);
如果没有返回值： 函数指针数组名[index] (实参列表);

练习：使用函数指针数组实现计算器

#include 
#include 
#include 

int add(int a,int b){
    return a+b;
}

int sub(int a,int b){
    return a-b;
}

int mul(int a,int b){
    return a*b;
}

int divv(int a,int b){
    return a/b;
}

int main(int argc, const char *argv[])
{
    int (*q[4])(int,int);
    q[0]=add;
    q[1]=sub;
    q[2]=mul;
    q[3]=divv;
    printf("400/200=%d\n",q[3](400,200));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

5 函数指针数组指针

函数指针数组指针：本质是一个指针，指向的是一个函数指针数组，函数指针数组中的成员是函数指针，
函数指针指向的是一个函数。

格式：
数据类型 (*(*函数指针数组指针变量名[成员个数]))(形参列表);

初始化：
定义函数指针数组：
数据类型 (*函数指针数组名[成员个数])(形参列表) = {函数名0,函数名1,…};

定义函数指针数组指针并初始化：
数据类型 (*(函数指针数组指针变量名1)[成员个数])(形参列表) = &函数指针数组名;
数据类型 ((*函数指针数组指针变量名2))(形参列表) = 函数指针数组名;

使用：
( * 函数指针数组指针变量名1) [ 0 ] (实参列表);
( * 函数指针数组指针变量名1) [ 1 ] (实参列表);
…

函数指针数组指针变量名20;
函数指针数组指针变量名21;
…

测试：

#include 
int add(int a, int b)
{
    return a + b;
}
int sub(int a, int b)
{
    return a - b;
}
int mul(int a, int b)
{
    return a * b;
}
int div(int a, int b)
{
    return a / b;
}

int main(int argc, const char *argv[])
{
    /*your code*/
    // 定义函数指针数组
    int (*cal_p_arr[4])(int, int);

    // 对函数指针数组的每个成员进行初始化
    cal_p_arr[0] = add;
    cal_p_arr[1] = sub;
    cal_p_arr[2] = mul;
    cal_p_arr[3] = div;

    printf("100 + 200 = %d\n", cal_p_arr[0](100, 200));
    printf("1000 - 200 = %d\n", cal_p_arr[1](1000, 200));
    printf("100 * 200 = %d\n", cal_p_arr[2](100, 200));
    printf("1000 / 200 = %d\n", cal_p_arr[3](1000, 200));

    // 定义函数指针数组指针
    int (*(*cal_p_arr_p1)[4])(int, int) = &cal_p_arr;
    printf("100 + 200 = %d\n", (*cal_p_arr_p1)[0](100, 200));
    printf("1000 - 200 = %d\n", (*cal_p_arr_p1)[1](1000, 200));
    printf("100 * 200 = %d\n", (*cal_p_arr_p1)[2](100, 200));
    printf("1000 / 200 = %d\n", (*cal_p_arr_p1)[3](1000, 200));

    // 定义函数指针数组指针
    int (*(*cal_p_arr_p2))(int, int) = cal_p_arr;
    printf("100 + 200 = %d\n", cal_p_arr_p2[0](100, 200));
    printf("1000 - 200 = %d\n", cal_p_arr_p2[1](1000, 200));
    printf("100 * 200 = %d\n", cal_p_arr_p2[2](100, 200));
    printf("1000 / 200 = %d\n", cal_p_arr_p2[3](1000, 200));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50