C语言--回调函数

使用场景

回调函数比喻：
你到一个商店买东西，刚好你要的东西没有货，于是你在店员那里留下了你的电话，过了几天店里有货了，店员就打了你的电话，然后你接到电话后就到店里去取了货。

在这个例子里，你的电话号码就叫回调函数，你把电话留给店员就叫登记回调函数，店里后来有货了叫做触发了回调关联的事件，店员给你打电话叫做调用回调函数，你到店里去取货叫做响应回调事件。

回调函数是一个程序员不能显式调用的函数；通过将回调函数的地址传给调用者从而实现调用。

回调函数使用是必要的，在我们想通过一个统一接口实现不同的内容，这时用回掉函数非常合适。

比如，我们为几个不同的设备分别写了不同的显示函数：

void TVshow(); void ComputerShow(); void NoteBookShow()…等等。

这是我们想用一个统一的显示函数，我们这时就可以用回掉函数了。void show(void (*ptr)()); 使用时根据所传入的参数不同而调用不同的回调函数。

通常一个项目由不同的人员负责。
假设各个模块的人都需要在某个事件产生的时候做一些事情，而检测这个事件是否产生是由一个人来完成的，那么这时候可以定义回调函数，大家都向这个负责检测的人进行注册。
当检测的人探测到事件发生的时候，通过回调函数来触发大家完成各自的事情。

回调函数通俗的解释：

• 普通函数：你所写的函数调用系统（他人）函数，你只管调用，不管实现。

• 回调函数：系统（他人）函数调用你所写的函数，你只管实现，不管调用。

回调函数的实现

简单来说，如果把一个函数的入口地址传递给一个函数指针，通过函数指针去调用这个函数，那么称这个函数为回调函数。

一般回调函数的用法为：

• 甲方进行结构体的定义（成员中包括回调函数的指针）
• 乙方定义结构体变量，并向甲方注册，
• 甲方收集N个乙方的注册形成结构体链表，在某个特定时刻遍历链表，进行回调。

下面代码是一个简单回调函数的例程：

#include <stdio.h>

/*进行结构体定义（成员中包括回调函数的指针）*/ 
struct operation {
    void (*callback)();
};

void a_callback() {
    printf("I'm A\n");
}

void b_callback() {
    printf("I'm B\n");
}

void trigger(struct operation *ops, int ops_length) {
    int i = 0;
    while(i++ < ops_length) {
        ops->callback();
        ops++;
    }
}

int main(int argc, char* argv[]) {
    /*定义结构体变量A、B，分别向operation注册各自的回调函数*/ 
    struct operation A,B;
    A.callback = &a_callback;
    B.callback = &b_callback;

    /*在某个特定事件触发的时候，遍历并执行所有注册的回调函数*/ 
    struct operation ops[2] = {A,B};
    trigger(ops, 2);
    return 0;
}

再看2个回调函数的例子

带参回调函数的用法：

#include <stdio.h>

int Test1()
{ 
     printf("Test1\n");           
     return 0;
}

int Test2( int num)
{
       int i;
       for (i=0; i< num; i++) {
               printf("The %dth charactor is:%c\n", i, (char)('a'+i%26));
       }
       return 0;
}

//不带参回调函数的用法,指向函数的指针作函数参数
void Caller1( int (*ptr)() )              
{
       (*ptr)();
}

//带参回调函数的用法
///不能写成void Caller2(int (*ptr)(int n))，这样的定义语法错误
void Caller2(int n, int (*ptr)(int) )       
{ 
       (*ptr)(n);
}

int main()
{
       Caller1(Test1); //相当于调用Test1(); 
       Caller2(5, Test2); //相当于调用Test2(5);
       return 0;
}

更常见的，使用typedef：

typedef定义回调函数

#include <stdio.h>
typedef int (*fp_t)(char c);

int f0(char c) { printf("f0, c = %c\n", c); return 0;}
int f1(char c) { printf("f1, c = %c\n", c); return 1;}


int main()
{
        int ret;
        fp_t fp;
        fp = f0;
        ret = fp('a');
        fp = f1;
        ret = fp('x');
        return 0;
}

运行结果：
f0, c = a
f1, c = x

#include <stdio.h>

/* 为回调函数命名，类型命名为callback，参数为char *p，可以同时声明指针型的多个对象*/
typedef void (*callback)(char *);//要实现回调，必须首先定义函数指针

void repeat(callback function, char *para)
{
    function(para);

}
void hello(char* a)
{
     printf("Hello %s\n",(const char *)a);
}
void count(char *num)
{
     int i;
     for(i=1;i<(int)num;i++)
          printf("%d",i);
     putchar('\n');
}
int main(void)
{
     repeat(hello,"Huangyi");
     repeat(count, (char *)4);
}

普通函数与回调函数的区别：

对普通函数的调用：调用程序发出对普通函数的调用后，程序执行立即转向被调用函数执行，直到被调用函数执行完毕后，再返回调用程序继续执行。从发出调用的程序的角度看，这个过程为“调用–>等待被调用函数执行完毕–>继续执行”

对回调函数调用：调用程序发出对回调函数的调用后，不等函数执行完毕，立即返回并继续执行。这样，调用程序执和被调用函数同时在执行。当被调函数执行完毕后，被调函数会反过来调用某个事先指定函数，以通知调用程序：函数调用结束。这个过程称为回调（Callback），这正是回调函数名称的由来

普通函数、回调函数都是被其他函数调用的，本身并无区别，不同之处在于调用者是否明确知道自己调用的到底是什么，举个例子:

void func1(){}
void func2(){}
typedef void (*fp)();//申明函数指针，fp表示一个空参数，返回类型void的函数指针
void funcCaller1(){
//此处func1可以看作普通函数
    func1();//此处，funcCall1明确知道自己调用了func1
}
void funcCaller2(fp funcPtr){
    funcPtr();//此处，funcCall2并不知道自己到底调用的是什么，只知道自己调用了一个空参数的，返回类型是void的函数
}
void funcCaller3(){
//此处，funcCaller2是普通函数，func1是回调函数
    funcCaller2(func1);//调用funcCaller2，参数是func1
//此处，funcCaller2是普通函数，func2是回调函数
    funcCaller2(func2);//调用funcCaller2，参数是func2
}