灵活性

使用 C 语言编程时，一般可以将函数调用增加一层封装，这样做可以让函数的使用更加灵活多变。

回调函数可以让函数功能调用起来更加的灵活，以下几种方式则是 C 语言中，实现代码重用的方法，他们由简单到灵活，也都是存在特定的使用背景的。

宏定义封装

＃define MacroFunction() Afunction(a, b, c) 将Afunction(a, b, c)的常用用法作为一个整体进行封装，这种封装形式，在后续使用时，如果需要修改值的话，可以直接修改＃define MacroFunction() Bfunction(a, b, c) 而无需再进行其他操作。但同时也存在问题，如果我们需要将一半的 Afunction(a, b, c) 改为 Bfunction(a, b, c) 就较为麻烦，如果采用这种方式的话就只能一个个查看替换了。遇到这种情况时，下一种方法是更好的选择。

静态入口函数

静态的入口函数，保证函数名相同，利用标志位调用子函数。这样的典型应用很多，比如说网卡驱动里面有一个入口函数Nilan（int FunctionCode，Para*）。具体的参数是什么记不清楚了。不过NiLan的主体是这样的：

1
2
3
4
5
6
7
8
9
Long Nila（int FunctionCode，Para*）
{
   Switch(FunctionCode)
   {
	   Case SendPacket: send(….)
	   Case ReceivePacket: receive(…)
	   ...
   }
}

写到这里大家明白什么意思了吧。保证相同的函数名就是说：网卡驱动是和pNA+协议栈互连的，那么如何保证pNA+协议栈和不同的驱动都兼容呢，一个简单的办法就是仅仅使用一个入口函数。

另外即便是一些初学者在写程序时，也会潜移默化地使用这种方法，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int Fun(int flag)
{
	if (flag == 0)
	{
		Afunction();
	}
	else if (flag > 0)
	{
		Bfunction();
	}
	else
	{
		Cfunction();
	}
}

通过改变如果函数的参数值，来调用内部的各个函数。这样的做法是可以进化的：如果以后想调用新的函数，增加相应的函数参数值就好了。

层与层之间的互连接口是很小的（这里是一个入口函数），一般是采用名字解析的办法而不是具体的函数调用（利用FunctionCode调用函数，Nilan仅仅实现名字解析的功能）。

回调(CALLBACK)函数

简述

回调函数才是本文的重点，它比上面的两种方法更加灵活，定制性更强。它使得一个函数可以在不重新编译的情况下实现功能的添加。一般使用回调函数可能存在有以下两点问题：

  • 效率降低：回调函数使用了函数指针，一般会先访问函数指针找到函数存放的实际地址，然后才是真正的函数调用，同直接调用函数比，多了一个寻址函数存储位置的过程（普通函数在编译时已经转换成了地址常亮，而函数指正仍然作为一个变量使用）。性能问题现在已经不做过多的考虑，指正调用本身就比较快，且现在机器性能都过剩。
  • 会导致程序的“支离破碎”：在程序中，你读到一个函数指针的时候，并不知道这个函数指针指向的是哪个函数，调用食会让程序碎片化严重。这点我暂时还不是太明了。

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

使用回调函数可以把调用者与被调用者分开。调用者不关心谁是被调用者，只是存在一个具有某种特定原型、某些限制条件（如返回值为int）的被调用函数。

有关函数指针

回调函数并不属于 C 语言最基本的用法，应该算是 C 语言使用的一个技巧，可以让 C 操作起来更加灵活，但灵活的代价就是你要对 C 语言比价熟悉，函数指针，指针函数等能够区分清除。

函数指针是指向函数的指针变量，即本质是一个指针变量。指向函数的指针包含了函数的地址，可以通过它来调用函数。声明格式如下：类型说明符 (*函数名)(参数)。

注意：函数名本身就是代表着指针/地址，因此并不需要再去取地址，使用 &/* 是没有太大的意义的。

1
2
3
4
5
6
7
8
9
10
11
12
13
void (*fptr)();
void Function(void)
{
	...
}
/* 以下两句等价 */
fptr=&Function;
fptr=Function;
/* 以下两句等价 */
x=(*fptr)();
x=fptr();

虽然 fptr=&Function; 和 x=(*fptr)();写起来都更加复杂，但是有些程序员倾向于使用这种格式，因为它明确指出是通过指针而非函数名来调用函数的，这边我也推荐使用这种写法。

常规步骤

一般编写这一系列回调及主调函数时，可以分为以下几个步骤：

  • 定义指向回调函数的类型，使用 typedef，如：typedef int (*typefun)(int); 表示 typefun 类型指向了类似于 int Test(int num) 这样的一个函数。
  • 调用回调函数的函数，有个形参类型为 typefun，代表我们使用这个函数时，会将回调函数作为参数传递给这个函数。
  • 开始调用，将回调函数的地址（即函数名）作为实参直接传递给调用回调函数的这个主调函数。

认真分析，我们可以发现，回调函数的使用就是传递了函数的地址，与传递普通变量的地址并没有实质的区别。

案例具体分析

下面举个回调函数的简单实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdlib.h>
#include <stdio.h>
typedef int (*typefun)(int);
int Test(int num)
{
	int i;
	for (i=0; i<num; i++)
	{
		printf("The %d th charactor is: %c/n", i, (char)('a' + i%26));
	}
	return 0;
}
void Caller(int n, typefun ptr)
{
	// 也能写成这样: void Caller(int n, int (*ptr)(int)) ,typedef 定义更加方便使用
	(*ptr)(n);
	return;
}
int main()
{
	Caller(30, Test); //相当于调用Test2(30);
	return 0;
}

以上的例子过于简单，并没有多大的实际意义，但我们通过这样的例子可以看出回调函数和上面讲述的静态入口函数都是在原本的函数上面多加了一层封装，为了让函数调用起来更加灵活多变。

更进一步，利用回调函数，C 语言能够实现很多技巧性的操作，下面扩充一个例子，用回调函数来实现的一个简单泛型程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/* 以下的泛型只是举例，如果需要比较浮点型，字符型则需要补充完善回调函数 */
#include <stdio.h>
typedef int (*cmp)(void *, void *);
typedef struct
{
    char *name;
    float score;
} stru_member, *pstru_member;
void *Max(void *p[], int len, cmp fun)
{
    void *res = p[0];
    for (int i = 0; i < len; i++)
    {
        if ((*fun)(p[i], res))		// 这边等价于 if (fun(p[i], res))
        {
            res = p[i];
        }
    }
    return res;
}
int comp(int *a, int *b)
{
    if (*a > *b)
        return 1;
    else
        return 0;
}
int mcomp(pstru_member a, pstru_member b)
{
    if (a->score > b->score)
        return 1;
    else
        return 0;
}
int main(void)
{
    int *pres;
    int data[5] = {1, 12, 30, 4, 5};
    int *pdata[5] = {&data[0], &data[1], &data[2], &data[3], &data[4]};
    pres = Max((void **)pdata, 5, (cmp)&comp);		// 这边等价于 pres = Max((void **)pdata, 5, (cmp)comp);	
    printf("%d\n", *pres);
    stru_member mem[3] = {{"no.1", 99.6}, {"no.2", 91.4}, {"no.3", 95.5}};
    pstru_member pmem[3] = {&mem[0], &mem[1], &mem[2]};
    pstru_member pres2 = Max((void **)pmem, 3, (cmp)&mcomp);
    printf("%s:%f\n", pres2->name, pres2->score);
}

调用方式

软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。同步调用是一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。回调和异步调用的关系非常紧密，通常我们使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。同步调用是三者当中最简单的，而回调又常常是异步调用的基础。

这几种调用方式并不完全是 C 语言中的常用方式，往往我们需要加入一些小技巧才可以完成这些功能的实现。

同步调用

现在有 A B C 三个事件，首先，A 事件完成了才可以触发 B 事件，然后 B 事件完成了，才可以触发 C 事件。这中间，如果 A 事件休眠了一段时间，B 也不得不等待，同样 B 出了问题，C 会等待 A 和 B 更长时间。

1
2
3
4
5
6
7
8
9
if A complete
do B
else 
wait A
if B complete
do C
else
wait B

这种就是典型的阻塞机制，无论如何我们只能等待上一个任务的完成，如果没有完成我们只能继续等待，这样造成的问题是，我们一直在浪费系统资源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void fun(void)
{
    int temp = 0;  
    while(!temp){  
      temp = wait(funA());  
    }    
    temp = 0;  
    while(!temp){  
      temp = wait(funB());  
    }  
    temp = 0;  
    while(!temp){  
      temp = wait(funC());  
    }  
}

回调

回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口。

对于一般的结构化语言，可以通过回调函数来实现回调。回调函数也是一个函数或过程，不过它是一个由调用方自己实现，供被调用方使用的特殊函数。在面向对象的语言中，回调则是通过接口或抽象类来实现的，我们把实现这种接口的类成为回调类，回调类的对象成为回调对象。对于象C++或Object Pascal这些兼容了过程特性的对象语言，不仅提供了回调对象、回调方法等特性，也能兼容过程语言的回调函数机制。

大家应该看到了，有两种做法，一种是先发送信号（执行回调函数），然后继续执行下面的代码。同样可以先执行代码再发送信号。

1
2
3
4
5
6
7
8
9
10
11
if A Message  
send to b   
do A  
  
if B Message From b  
do B  
send to c  
  
if B complete  
do C  
message from c

这种就是在函数的参数中带有一个其他函数指针，当需要的时候我们可以通过函数指针名进行调用其他函数即发送消息到其他函数。

1
2
3
4
5
6
7
8
9
10
void fun(A, callback)
{  
   callback();  
   funA();  
}  
  
void callback()
{  
   funB();
}

异步调用

异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
F tell A  
  do A  
  time 2 hours  
  if A complete Report to F  
F tell B  
  do B  
 time 1 hours  
  if B complete Report to F  
F tell C  
  do C  
 time 1.5 hours  
  if C complete Report to F  
F tell D  
  do D  
  time 3 hours  
  if D complete Report to F

四个程序虽然有先后次序整体上看是依次执行的，但是执行的过程中，我们并不会因为前面的代码没有执行完，而不执行。

回调函数在 C 语言中太过常用，往往一些高级的操作都需要使用这个技巧，后续还会更新一些关于回调函数技巧使用的一些文章。

参考链接：
http://c.biancheng.net/cpp/html/1202.html
http://blog.codingnow.com/2010/03/object_oriented_programming_in_c.html
https://www.zhihu.com/question/19801131
http://blog.csdn.net/tzshlyt/article/details/52993282
http://www.cnblogs.com/kunhu/p/3713370.html
http://www.cnblogs.com/kunhu/p/3700610.html
http://blog.csdn.net/dan_blog/article/details/7897852
http://bbs.bccn.net/thread-457131-1-1.html
https://www.ibm.com/developerworks/cn/linux/l-callback/
http://xenyinzen.wikidot.com/reship:080123-8

写作时间：21:39-22:56