c语言-函数指针和回调函数

函数指针,顾名思义指向函数的指针

函数的首地址在代码区,函数名就是一个函数的首地址

函数指针的定义如下

函数的返回类型 (*函数指针变量名)(参数类型1, 参数类型2......) = 初始值;

若两个函数指针完全相同 则函数的返回类型和参数的个数以及类型都是相同的.

例如

int max(int x, int y){

                 return x > y ? x : y;

}

int  sum(int x, inty){

return x +y;

}

在main函数中可以这样使用如下两个函数

int a = 9, b = 3;

max(a, b);

sum(a, b);

我们发现上面的两个函数中都有一个返回类型为int型,并且都是有两个参数,而且类型是相同的.我们这个时候就可以定义一个函数指针

如下

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

这个时候如果我们想求最大值,我们就可以用p指针来调用这个函数,我们上面说过函数的名字即是函数的首地址,我们可以让p指针指向这个函数的首地址

即p = max;

这样便可以通过p来调用这个函数了p(a, b);

当然我们也可以用p来调用sum这个求和函数,p是一个函数指针变量,可以重定向,即可以指向max函数也可以指向sum这个函数

p = sum; p(a, b); 这样就可以求出最大值.

但是这个时候我们会发现一个问题,我们在想使用sum 和max函数的时候需要调用两次,我们可以把函数指针作为函数的参数,这样我们在main函数中传入max或者是sum这样便可以自动根据我们的需要求出想要的结果

改进如下:

typedef int (*p) (int , int);//这是对函数指针类型的重命名,和别的typedef不同的是,这个时候新命的名字在*后面,我们这个即p指针

int function(int x, int y, p type);

int max(int x, inty);

int  sum(int x, inty);

int max(int x, inty){

return x > y ? x : y;

}

int sum(int x, inty){

return x + y;

}

int function(int x, int y, p type){

return type(x, y);

}

这个时候在mian函数中,如果想求两个数的和以及最大值便可以如下

int a = 2, b = 3;

function(2, 3, sum);

function(2, 3, max);

这便是回调函数的用法:使用指针来调用函数

我们现在对我们经常对学生信息排序用一个回调函数来实现

首先定义一个结构体数组

struct student{

char name[20];

int age;

};

typedef student Student;

//我们来定义一个结构体数组

Student stu[3] = {

{"liyang", 56},

{"liyan", 23},

{"liming", 24}

};

如果我们想对年龄排序我们通常会写如下函数:

void bubbleSort (Student *p, int n){

BOOL flag= YES;

for(int i = 0; i < n - 1; i ++){

flag = NO;

for(int j = 0; j < n - 1 - i; j++){

if((p + j)- > age > (p + j + 1)){

Student temp = *(p + j);

*(p + j) = *(p + j + 1);

*(p + j + 1) = temp;

}

}

}

}

如果我们想对学生按照姓名排序,就要再if这个判断条件修改一下,改成判断姓名就可以了,别的并没有修改

这个时候我们可以把这个判断条件写成一个函数如下

BOOL isAge(Student *stu1, Student *stu2);

BOOL isAge(Student *stu1, Student *stu2){

return stu1-> age  > stu2->age;//条件关系符返回的是一个布尔值,如果表达式成立,则返回YES,如果表达式不成立,则返回NO

}

BOOL isName(Student *stu1, Student *stu2);

BOOL isName(Student *stu1, Student *stu2){

return strcmp(stu1->name  > stu2->name) > 0;

}

这个时候冒泡中的条件就可以写成 isAge((p + j), (p + j + 1));

但是这个时候还是不是很好,我们可以如上面的回调函数一样,用函数指针作为形参

typedef BOOL (* type) (Student *stu1, Student *stu2);

void bubbleSort (Student *p, int n, type rt){

BOOL flag= YES;

for(int i = 0; i < n - 1; i ++){

flag = NO;

for(int j = 0; j < n - 1 - i; j++){

if(rt(p + j), (p + j + 1)){

Student temp = *(p + j);

*(p + j) = *(p + j + 1);

*(p + j + 1) = temp;

}

}

}

}

这样在主函数中就可以使用

bubbleSort (stu, 3, isName);//按照名字排序

bubbleSort (stu, 3, isAge);//按照年龄排序

但是如果客户的话,他可能不知道isAge是什么isName是什么,但是他想按照"name"排序

可能就会传入

bubbleSort (stu, 3, "name");

这个时候我们怎么样调用呢,当然我们之前的函数仍然可以使用,这个时候我们可以把name传过去,然后接受的时候判断一下是该执行那个函数,然后返回那个函数的地址,这个时候我们就要返回一个一个函数的指针,我们把判断的语句单独拿出来即如下所示

typedef  BOOL(* sortType ) (student *, student *);

sortType isType(char *string){

if(strcmp(string) == "name"){

return isName;

} else if (strcmp(string) == "age"){

return isAge;

} else {

return isName;//如果不是name或者是age则默认按姓名排序

}

}

void bubbleSort (Student *p, int n, char *string){

sortType rt = isType(string);

BOOL flag= YES;

for(int i = 0; i < n - 1; i ++){

flag = NO;

for(int j = 0; j < n - 1 - i; j++){

if(rt(p + j), (p + j + 1)){

Student temp = *(p + j);

*(p + j) = *(p + j + 1);

*(p + j + 1) = temp;

}

}

}

}