附3.函数指针

一.函指针概述

函数的作用：完成某一特定功能的代码块。

指针的作用：一种特殊的变量，用来保存地址值，某类型的指针指向某类型的地址。

下面定义了一个求两个数最大值的函数：
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);

三.回调函数

现在我们有这样一个需求：实现一个函数，将一个整形数组中比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!"对于提需求者，你可能此时的心情是这样：

然而回到现实，这种需求是不可避免的，你可能想过复制粘贴，更改一下判断条件，然而作为开发者，我们要未雨绸缪，要考虑到将来可能添加更多类似的需求，那么你将会有大量的重复代码，使你的项目变得臃肿，所以这个时候我们需要冷静下来思考，其实这两个需求很多代码都是相同的，只要更改一下判断条件即可，而判断条件我们如何变得更加灵活呢？这时候我们就用到回调函数的知识了，我们可以定义一个函数，这个函数需要两个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);

这种声明从外观上看更像是脸滚键盘出来的结果，现在让我们来逐步的分析一下这个声明的组成步骤：

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你会发现，所有的方法调用的实现原理都是如此。

补充：strcmp

原型：int strcmp(const char *s1, const char *s2);
头文件：#include <string.h>

功能：用来比较两个字符串
参数：s1、s2为两个进行比较的字符串
返回值：若s1、s2字符串相等，则返回零；若s1大于s2，则返回大于零的数；否则，则返回小于零的数。
说明：strcmp()函数是根据ACSII码的值来比较两个字符串的；strcmp()函数首先将s1字符串的第一个字符值减去s2第一个字符，若差值为零则继续比较下去；若差值不为零，则返回差值。