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是一个标识符

  2. findFunction()是一个函数

  3. findFunction(char *)函数接受一个种类也char *的参数
  4. *findFunction(char *)函数返回一个指南针
  5. (*findFunction(char*))()这个指针指向一个函数
  6. (*findFunction(char*))(int, int)指针指向的函数接受两独整形参数
  7. 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你见面发现,所有的法调用的落实原理都是这样。

函数指针数组


现咱们应有懂得表达式“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语言已经远非呀会阻止你了。