C语言-函数指针(Function Pointer)及进阶

前言


初学C语言的童鞋,常常在学完函数和指针的学问后,已经是萌萌哒,学习到了函数指针(请小心不是函数和指针),更是所有人都糟糕了,这篇小说的目标,就是支援自己的童鞋们领悟函数指针。�

函数指针概述


第一大家须要回想一下函数的功力:已毕某一一定成效的代码块。
再来回想一下指南针的效应:一种独特的变量,用来保存地址值,某项目标指针指向某项目标地点。
下边定义了一个求五个数最大值的函数:

int maxValue (int a, int b) {
    return a > b ? a : b;
}     

而那段代码编译后生成的CPU指令存储在代码区,而那段代码其实是可以得到其地址的,而其地址就是函数名,我们得以行使指针存储那么些函数的地址——函数指针。
函数指针其实就是一种独特的指针——指向一个函数的指针。在诸多高等语言中,它的思考是很重点的,尤其是它的“回调函数”,所以通晓它是很有必不可少的。

函数指针定义与利用


其余变量定义都富含三部分: 变量类型 + 变量名 =
初值,那么定义一个函数指针,首先我们须要精通要定义一个怎样的函数指针(指针类型),那么难点来了,函数的品种又是哪些吧?我们继承分析这段代码:

int maxValue (int a, int b) {
    return a > b ? a : b;
}    

那几个函数的项目是有八个整型参数,再次来到值是个整型。对应的函数指针类型:

int (*) (int a, int b);  

相应的函数指针定义:

int (*p)(int x, int  y);    

参数名可以去掉,并且普通都是去掉的。那样指针p就足以保存函数类型为多少个整型参数,重临值是整型的函数地址了。

int (*p)(int, int);

由此函数指针调用函数:

int (*p)(int, int) = NULL;
p = maxValue;
p(20, 45);

回调函数


上述内容是函数指针的基础用法,不过大家可以看得出来,直接运用函数maxValue岂不是更有利?没错,其实函数指针更要紧的含义在于函数回调,而上述情节只是一个搭配。
举个例证:
现在大家有如此一个需求:完毕一个函数,将一个整形数组中比50大的打印在控制台,大家也许这么落成:

void compareNumberFunction(int *numberArray, int count, int compareNumber) {
    for (int i = 0; i < count; i++) {
        if (*(numberArray + i) > compareNumber) {
            printf("%d\n", *(numberArray + i));
        }
    }
}
int main() {

    int numberArray[5] = {15, 34, 44, 56, 64};
    int compareNumber = 50;
    compareNumberFunction(numberArray, 5, compareNumber);

    return 0;
}   

这么完毕是绝非难点的,然则现在大家又有诸如此类一个须求:落成一个函数,将一个整形数组中比50小的打印在控制台。”What
the fuck!”对于提须要者,你可能此时的心气是这般:

</img>
而是回到现实,那种须求是不可幸免的,你恐怕想过复制粘贴,更改一下论断标准,但是作为开发者,大家要预备,要考虑到明日说不定助长越多类似的要求,那么你将会有雅量的重新代码,使您的连串变得臃肿,所以这几个时候大家必要冷静下来思考,其实那四个要求很多代码都是如出一辙的,只要改变一下判定标准即可,而判断标准大家什么样变得尤为灵活呢?那时候大家就用到回调函数的学问了,大家得以定义一个函数,那几个函数要求五个int型参数,函数内部贯彻代码是将八个整形数字做相比较,将比较结实的bool值作为函数的再次回到值重临出来,以超乎被相比数字的意况为例:

BOOL compareGreater(int number, int compareNumber) {
    return number > compareNumber;
}   

同理,小于被相比的数字函数定义如下:

BOOL compareLess(int number, int compareNumber) {
    return number < compareNumber;
}

接下去,大家可以将以此函数作为compareNumberFunction的一个参数举行传递(没错,函数可以当做参数),那么大家就要求一个函数指针获取函数的地址,从而在compareNumberFunction内部举行对函数的调用,于是,compareNumberFunction函数的概念变成了那样:

void compareNumberFunction(int *numberArray, int count, int compareNumber, BOOL (*p)(int, int)) {
    for (int i = 0; i < count; i++) {
        if (p(*(numberArray + i), compareNumber)) {
            printf("%d\n", *(numberArray + i));
        }
    }
}

切实采纳一代吗之类:

int main() {

    int numberArray[5] = {15, 34, 44, 56, 64};
    int compareNumber = 50;
    // 大于被比较数字情况:
    compareNumberFunction(numberArray, 5, compareNumber, compareGreater);
    // 小于被比较数字情况:
    compareNumberFunction(numberArray, 5, compareNumber, compareLess);

    return 0;
}

根据上述案例,大家能够得出结论:函数回调本质为函数指针作为函数参数,函数调用时传出函数地址,那使我们的代码变得尤为灵敏,可复用性更强。

动态排序


地点的案例一经你已经清楚的话那么动态排序其实你早已懂了。首先大家应当知道动态这些词,我的领会就是见仁见智随时,分化场景,爆发区其余事,那就是动态。话不多说,直接上案例。
须要: 有30个学生须要排序
按战表排
按年龄排

那种不可以臆度的急需变动,就是大家上文说的动态场景,那么解决方案就是函数回调:

typedef struct student{
    char name[20];
    int age;
    float score;
}Student;

//比较两个学生的年龄
BOOL compareByAge(Student stu1, Student stu2) {
    return stu1.age > stu2.age ? YES : NO;
}
//比较两个学生的成绩
BOOL compareByScore(Student stu1, Student stu2) {
    return stu1.score > stu2.score ? YES : NO;
}
void sortStudents(Student *array, int n, BOOL(*p)(Student, Student)) {
    Student temp;
    int flag = 0;
    for (int i = 0; i < n - 1 && flag == 0; i++) {
        flag = 1;
        for (int j = 0; j < n - i - 1; j++) {
            if (p(array[j], array[j + 1])) {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                flag = 0;
            }
        }
    }
}
int main() {

    Student stu1 = {"小明", 19, 98};
    Student stu2 = {"小红", 20, 78};
    Student stu3 = {"小白", 21, 88};
    Student stuArray[3] = {stu1, stu2, stu3};
    sortStudents(stuArray, 3, compareByScore);

    return 0;
}

不错,动态排序就是这么简单!

函数指针作为函数重临值

没错,既然函数指针可以用作参数,自然也得以视作重返值。再跟着上案例。
需求:定义一个函数,通过传播作用的名号获取到相应的函数。

整理一下发型,然后咱们解析下须求,当前大家需求定义一个称为findFunction的函数,那一个函数传入一个字符串之后会回来一个
int (*)(int,
int)类型的函数指针,那么大家以此函数的宣示是还是不是可以写成这么啊?

int (*)(int, int) findFunction(char *);   

那看起来很吻合大家的明亮,可是,那并不得法,编译器不可以识别七个完全并行的蕴藏形参的括号(int,
int)和(char *),真正的款型其实是那般:

int (*findFunction(char *))(int, int);  

这种申明从外观上看更像是脸滚键盘出来的结果,现在让大家来逐步的分析一下这一个宣称的结合步骤:

  1. findFunction是一个标识符
  • findFunction()是一个函数
  • findFunction(char *)函数接受一个品种为char *的参数
  • *findFunction(char *)函数重回一个指针
  • (*findFunction(char*))()这些指针指向一个函数
  • (*findFunction(char*))(int, int)指针指向的函数接受七个整形参数
  • int (*findFunction(char *))(int, int)指针指向的函数重回一个整形

现在大家的分析已经形成了,编译器可以经过了,现在程序员疯了,这对大家的话就像是鲱鱼罐头一样难以下咽,那么我们是还是不是有更好的书写方式吗?(老车手友情提示:typedef)

末段代码衍变成了那般:

// 重定义函数指针类型
typedef int (*FUNC)(int, int);

// 求最大值函数
int maxValue(int a, int b) {
    return a > b ? a : b;
}

// 求最小值函数
int minValue(int a, int b) {
    return a < b ? a : b;
}
// findFunction函数定义
FUNC findFunction(char *name) {
    if (0 == strcmp(name, "max")) {
        return maxValue;
    } else if (0 == strcmp(name, "min")) {
        return minValue;
    }

    printf("Function name error");
    return NULL;
}   

int main() {

    int (*p)(int, int) = findFunction("max");
    printf("%d\n", p(3, 5));

    int (*p1)(int, int) = findFunction("min");
    printf("min = %d\n", p1(3, 5));

    return 0;
}

到了此地,函数指针的基本功内容早已终结了,有的同学还有可能困惑,为何我要以函数去获取函数呢,直接运用maxValue和minValue不就好了么,其实在今后的编程进度中,很有可能maxValue和minValue被打包了四起,类的外表是无法直接选用的,那么大家就必要那种措施,要是您读书了Objective-C你会发现,所有的措施调用的达成原理都是这么。

函数指针数组


C语言,近年来大家应有精通表明式“char * (*pf)(char *
p)”定义的是一个函数指针pf。既然pf
是一个指南针,那就可以储存在一个数组里。把上式修改一下:
char * (*pf[3])(char * p);
那是概念一个函数指针数组。它是一个数组,数组名为pf,数组内囤积了3
个指向函数的指针。这几个指针指向一些回到值类型为指向字符的指针、参数为一个针对字符的指针的函数。那念起来似乎不怎么生硬。不过没什么,关键是你了然那是一个指南针数组,是数组。

函数指针数组怎么选用呢?给一个卓殊简单的例证,只要真的控制了利用办法,再繁杂的难点都足以回答。如下:

char * fun1(char * p)
{
   printf("%s\n",p);
   return p;
}
char * fun2(char * p)
{
   printf("%s\n",p);
   return p;
}
char * fun3(char * p)
{
   printf("%s\n",p);
   return p;
}
int main(){
   char * (*pf[3])(char * p);
   pf[0] = fun1; // 可以直接用函数名
   pf[1] = &fun2; // 可以用函数名加上取地址符
   pf[2] = &fun3;
   pf[0]("fun1");
   pf[0]("fun2");
   pf[0]("fun3");
   return 0;
}

是否觉得方面的事例太简单,不够刺激?好,那就来点刺激的。

函数指针数组的指针

瞧着那么些题目没发狂吧?函数指针就够一般初学者折腾了,函数指针数组就越来越艰辛,现在的函数指针数组指针就更难通晓了。

实际上,没那样复杂。前边详细座谈过数组指针的题材,那里的函数指针数组指针不就是一个指南针嘛。只不过那几个指针指向一个数组,那么些数组里面存的都是指向函数的指针。仅此而已。

上边就定义一个简单的函数指针数组指针:
char * (*(*pf)[3])(char * p);
注意,那里的pf 和方面的pf 就全盘是两码事了。上一节的pf
并非指针,而是一个数组名;那里的pf
确实是确凿的指针。这一个指针指向一个暗含了3
个元素的数组;那些数字里面存的是指向函数的指针;那些指针指向一些重返值类型为指向字符的指针、参数为一个对准字符的指针的函数。那比面的函数指针数组更拗口。其实您不用管如此多,领悟那是一个指针就ok
了。其用法与眼前讲的数组指针没有不一致。上边列一个简短的事例:

char * fun1(char * p)
{
   printf("%s\n",p);
   return p;
}
char * fun2(char * p)
{
   printf("%s\n",p);
   return p;
}
char * fun3(char * p)
{
   printf("%s\n",p);
   return p;
}
int main(){
   char * (*a[3])(char * p);
   char * (*(*pf)[3])(char * p);
   pf = &a;
   a[0] = fun1;
   a[1] = &fun2;
   a[2] = &fun3;
   pf[0][0]("fun1");
   pf[0][1]("fun2");
   pf[0][2]("fun3");
   return 0;
}

好了,到了此地C语言已经没有怎么能阻碍你了。