C语言---回调函数

C语言---回调函数------------->解析 收藏

什么是回调函数？

简而言之，回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。

为什么要使用回调函数？

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

如果想知道回调函数在实际中有什么作用，先假设有这样一种情况，我们要编写一个库，它提供了某些排序算法的实现，如冒泡排序、快速排序、shell排序、shake排序等等，但为使库更加通用，不想在函数中嵌入排序逻辑，而让使用者来实现相应的逻辑；或者，想让库可用于多种数据类型（int、float、string），此时，该怎么办呢？可以使用函数指针，并进行回调。

回调可用于通知机制，例如，有时要在程序中设置一个计时器，每到一定时间，程序会得到相应的通知，但通知机制的实现者对我们的程序一无所知。而此时，就需有一个特定原型的函数指针，用这个指针来进行回调，来通知我们的程序事件已经发生。实际上，SetTimer() API使用了一个回调函数来通知计时器，而且，万一没有提供回调函数，它还会把一个消息发往程序的消息队列。

另一个使用回调机制的API函数是EnumWindow()，它枚举屏幕上所有的顶层窗口，为每个窗口调用一个程序提供的函数，并传递窗口的处理程序。如果被调用者返回一个值，就继续进行迭代，否则，退出。EnumWindow()并不关心被调用者在何处，也不关心被调用者用它传递的处理程序做了什么，它只关心返回值，因为基于返回值，它将继续执行或退出。

不管怎么说，回调函数是继续自C语言的，因而，在C++中，应只在与C代码建立接口，或与已有的回调接口打交道时，才使用回调函数。除了上述情况，在C++中应使用虚拟方法或函数符（functor），而不是回调函数。

一个简单的回调函数实现

下面创建了一个sort.dll的动态链接库，它导出了一个名为CompareFunction的类型--typedef int (__stdcall *CompareFunction)(const byte*, const byte*)，它就是回调函数的类型。另外，它也导出了两个方法：Bubblesort()和Quicksort()，这两个方法原型相同，但实现了不同的排序算法。

void DLLDIR __stdcall Bubblesort(byte* array,int size,int elem_size,CompareFunction cmpFunc);

void DLLDIR __stdcall Quicksort(byte* array,int size,int elem_size,CompareFunction cmpFunc);

这两个函数接受以下参数：

·byte * array：指向元素数组的指针（任意类型）。

·int size：数组中元素的个数。

·int elem_size：数组中一个元素的大小，以字节为单位。

·CompareFunction cmpFunc：带有上述原型的指向回调函数的指针。

这两个函数的会对数组进行某种排序，但每次都需决定两个元素哪个排在前面，而函数中有一个回调函数，其地址是作为一个参数传递进来的。对编写者来说，不必介意函数在何处实现，或它怎样被实现的，所需在意的只是两个用于比较的元素的地址，并返回以下的某个值（库的编写者和使用者都必须遵守这个约定）：

·-1：如果第一个元素较小，那它在已排序好的数组中，应该排在第二个元素前面。

·0：如果两个元素相等，那么它们的相对位置并不重要，在已排序好的数组中，谁在前面都无所谓。

·1：如果第一个元素较大，那在已排序好的数组中，它应该排第二个元素后面。

基于以上约定，函数Bubblesort()的实现如下，Quicksort()就稍微复杂一点：

void DLLDIR __stdcall Bubblesort(byte* array,int size,int elem_size,CompareFunction cmpFunc)

{

for(int i=0; i < size; i++)

{

for(int j=0; j < size-1; j++)

{

//回调比较函数

if(1 == (*cmpFunc)(array+j*elem_size,array+(j+1)*elem_size))

{

//两个相比较的元素相交换

byte* temp = new byte[elem_size];

memcpy(temp, array+j*elem_size, elem_size);

memcpy(array+j*elem_size,array+(j+1)*elem_size,elem_size);

memcpy(array+(j+1)*elem_size, temp, elem_size);

delete [] temp;

}

}

}

}

注意：因为实现中使用了memcpy()，所以函数在使用的数据类型方面，会有所局限。

对使用者来说，必须有一个回调函数，其地址要传递给Bubblesort()函数。下面有二个简单的示例，一个比较两个整数，而另一个比较两个字符串：

int __stdcall CompareInts(const byte* velem1, const byte* velem2)

{

int elem1 = *(int*)velem1;

int elem2 = *(int*)velem2;

if(elem1 < elem2)

return -1;

if(elem1 > elem2)

return 1;

return 0;

}

int __stdcall CompareStrings(const byte* velem1, const byte* velem2)

{

const char* elem1 = (char*)velem1;

const char* elem2 = (char*)velem2;

return strcmp(elem1, elem2);

}

下面另有一个程序，用于测试以上所有的代码，它传递了一个有5个元素的数组给Bubblesort()和Quicksort()，同时还传递了一个指向回调函数的指针。

int main(int argc, char* argv[])

{

int i;

int array[] = {5432, 4321, 3210, 2109, 1098};

cout << "Before sorting ints with Bubblesort/n";

for(i=0; i < 5; i++)

cout << array[i] << '/n';

Bubblesort((byte*)array, 5, sizeof(array[0]), &CompareInts);

cout << "After the sorting/n";

for(i=0; i < 5; i++)

cout << array[i] << '/n';

const char str[5][10] = {"estella","danielle","crissy","bo","angie"};

cout << "Before sorting strings with Quicksort/n";

for(i=0; i < 5; i++)

cout << str[i] << '/n';

Quicksort((byte*)str, 5, 10, &CompareStrings);

cout << "After the sorting/n";

for(i=0; i < 5; i++)

cout << str[i] << '/n';

return 0;

}

如果想进行降序排序（大元素在先），就只需修改回调函数的代码，或使用另一个回调函数，这样编程起来灵活性就比较大了。

调用约定

上面的代码中，可在函数原型中找到__stdcall，因为它以双下划线打头，所以它是一个特定于编译器的扩展，说到底也就是微软的实现。任何支持开发基于Win32的程序都必须支持这个扩展或其等价物。以__stdcall标识的函数使用了标准调用约定，为什么叫标准约定呢，因为所有的Win32 API（除了个别接受可变参数的除外）都使用它。标准调用约定的函数在它们返回到调用者之前，都会从堆栈中移除掉参数，这也是Pascal的标准约定。但在C/C++中，调用约定是调用者负责清理堆栈，而不是被调用函数；为强制函数使用C/C++调用约定，可使用__cdecl。另外，可变参数函数也使用C/C++调用约定。

Windows操作系统采用了标准调用约定（Pascal约定），因为其可减小代码的体积。这点对早期的Windows来说非常重要，因为那时它运行在只有640KB内存的电脑上。

如果你不喜欢__stdcall，还可以使用CALLBACK宏，它定义在windef.h中：

#define CALLBACK __stdcallor

#define CALLBACK PASCAL //而PASCAL在此被#defined成__stdcall

作为回调函数的C++方法

因为平时很可能会使用到C++编写代码，也许会想到把回调函数写成类中的一个方法，但先来看看以下的代码：

class CCallbackTester

{

public:

int CALLBACK CompareInts(const byte* velem1, const byte* velem2);

};

Bubblesort((byte*)array, 5, sizeof(array[0]),

&CCallbackTester::CompareInts);

如果使用微软的编译器，将会得到下面这个编译错误：

error C2664: 'Bubblesort' : cannot convert parameter 4 from 'int (__stdcall CCallbackTester::*)(const unsigned char *,const unsigned char *)' to 'int (__stdcall *)(const unsigned char *,const unsigned char *)' There is no context in which this conversion is possible

这是因为非静态成员函数有一个额外的参数：this指针，这将迫使你在成员函数前面加上static。当然，还有几种方法可以解决这个问题，但限于篇幅，就不再论述了 .

2 补充BBS评论

回调到底层次的看法就是:

让函数去"自主"调用函数,而不是由你决定.

typedef void (*VP)(void);

void Task1()

{

...

}

void Task2()

{

...

}

void EX_CallBack()

{

VP M = NULL;

if (condition)

{

M = Task1;

}

else

{

M = Task2;

}

M();

}

短歌说:它算是一种动态绑定的技术,

主要用于对某一事件的正确响应.

3.声明函数指针并回调

程序员常常需要实现回调。本文将讨论函数指针的基本原则并说明如何使用函数指针实现回调。注意这里针对的是普通的函数，不包括完全依赖于不同语法和语义规则的类成员函数（类成员指针将在另文中讨论）。

声明函数指针

回调函数是一个程序员不能显式调用的函数；通过将回调函数的地址传给调用者从而实现调用。要实现回调，必须首先定义函数指针。尽管定义的语法有点不可思议，但如果你熟悉函数声明的一般方法，便会发现函数指针的声明与函数声明非常类似。请看下面的例子：

void f()；// 函数原型

上面的语句声明了一个函数，没有输入参数并返回void。那么函数指针的声明方法如下：

void (*) ();

让我们来分析一下，左边圆括弧中的星号是函数指针声明的关键。另外两个元素是函数的返回类型（void）和由边圆括弧中的入口参数（本例中参数是空）。注意本例中还没有创建指针变量-只是声明了变量类型。目前可以用这个变量类型来创建类型定义名及用sizeof表达式获得函数指针的大小：

// 获得函数指针的大小

unsigned psize = sizeof (void (*) ());

// 为函数指针声明类型定义

typedef void (*pfv) ();

pfv是一个函数指针，它指向的函数没有输入参数，返回类行为void。使用这个类型定义名可以隐藏复杂的函数指针语法。

指针变量应该有一个变量名：

void (*p) (); //p是指向某函数的指针

p是指向某函数的指针，该函数无输入参数，返回值的类型为void。左边圆括弧里星号后的就是指针变量名。有了指针变量便可以赋值，值的内容是署名匹配的函数名和返回类型。例如：

void func()

{

}

p = func;

p的赋值可以不同，但一定要是函数的地址，并且署名和返回类型相同。

传递回调函数的地址给调用者

现在可以将p传递给另一个函数（调用者）- caller()，它将调用p指向的函数，而此函数名是未知的：

void caller(void(*ptr)())

{

ptr();

}

void func();

int main()

{

p = func;

caller(p);

}

如果赋了不同的值给p（不同函数地址），那么调用者将调用不同地址的函数。赋值可以发生在运行时，这样使你能实现动态绑定。

调用规范

到目前为止，我们只讨论了函数指针及回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几种调用规范。如在Visual C++中，可以在函数类型前加_cdecl，_stdcall或者_pascal来表示其调用规范（默认为_cdecl）。C++ Builder也支持_fastcall调用规范。调用规范影响编译器产生的给定函数名，参数传递的顺序（从右到左或从左到右），堆栈清理责任（调用者或者被调用者）以及参数传递机制（堆栈，CPU寄存器等）。

将调用规范看成是函数类型的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：

// 被调用函数是以int为参数，以int为返回值

__stdcall int callee(int);

// 调用函数以函数指针为参数

void caller( __cdecl int(*ptr)(int));

// 在p中企图存储被调用函数地址的非法操作

__cdecl int(*p)(int) = callee; // 出错

指针p和callee()的类型不兼容，因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p，尽管两者有相同的返回值和参数列

4。函数指针和回调函数

函数指针和回调函数

你不会每天都使用函数指针，但是，它们确有用武之地，两个最常见的用途是把函数指针作为参数传递给另一个函数以及用于转换表（jump table）。

【警告】简单声明一个函数指针并不意味着它马上就可以使用。和其它指针一样，对函数指针执行间接访问之前必须把它初始化为指向某个函数。下面的代码段说明了一种初始化函数指针的方法。

int f（int）；

int （*pf）（int）＝&f；

第 2 个声明创建了函数指针 pf ，并把它初始化为指向函数 f 。函数指针的初始化也可以通过一条赋值语句来完成。 在函数指针的初始化之前具有 f 的原型是很重要的，否则编译器就无法检查 f 的类型是否与 pf 所指向的类型一致。

初始化表达式中的 & 操作符是可选的，因为函数名被使用时总是由编译器把它转换为函数指针。 & 操作符只是显式地说明了编译器隐式执行的任务。

在函数指针被声明并且初始化之后，我们就可以使用三种方式调用函数：

int ans；

ans＝f（25）；

ans＝（*pf）（25）；

ans＝pf（25）；

第 1 条语句简单地使用名字调用函数 f ，但它的执行过程可能和你想象的不太一样。 函数名 f 首先被转换为一个函数指针，该指针指定函数在内存中的位置。然后， 函数调用操作符调用该函数，执行开始于这个地址的代码。

第 2 条语句对 pf 执行间接访问操作，它把函数指针转换为一个函数名。这个转换并不是真正需要的，因为编译器在执行函数调用操作符之前又会把它转换回去。不过，这条语句的效果和第1条是完全一样的。

第 3 条语句和前两条的效果是一样的。间接访问并非必需，因为编译器需要的是一个函数指针。

（一）回调函数

这里有一个简单的函数，它用于在单链表中查找一个值。它的参数是一个指向链表第 1 个节点的指针以及那个需要查找的值。

Node *

search_list（Node *node, int const value）

{

while（node!=NULL）{

if( node->value == value )

break;

node = node->link;

}

return node;

}

这个函数看上去相当简单，但它只适用于值为整数的链表。如果你需要在一个字符串链表中查找，你不得不另外编写一个函数。这个函数和上面那个函数的绝大部分代码相同，只是第 2 个参数的类型以及节点值的比较方法不同。

一种更为通用的方法是使查找函数与类型无关，这样它就能用于任何类型的值的链表。我们必须对函数的两个方面进行修改，使它与类型无关。

首先，我们必须改变比较的执行方式，这样函数就可以对任何类型的值进行比较。这个目标听上去好像不可能，如果你编写语句用于比较整型值，它怎么还可能用于其它类型如字符串的比较呢？ 解决方案就是使用函数指针。调用者编写一个比较函数，用于比较两个值，然后把一个指向此函数的指针作为参数传递给查找函数。而后查找函数来执行比较。使用这种方法，任何类型的值都可以进行比较。

我们必须修改的第 2 个方面是向比较函数传递一个指向值的指针而不是值本身。比较函数有一个 void * 形参，用于接收这个参数。然后指向这个值的指针便传递给比较函数。（这个修改使字符串和数组对象也可以被使用。字符串和数组无法作为参数传递给函数，但指向它们的指针却可以。）

使用这种技巧的函数被称为回调函数（callback function），因为用户把一个函数指针作为参数传递其它函数，后者将”回调“用户的函数。任何时候，如果你所编写的函数必须能够在不同的时刻执行不同类型的工作或者执行只能由函数调用者定义的工作，你都可以使用这个技巧。

【提示】

在使用比较函数的指针之前，它们必须被强制转换为正确的类型。因为强制类型转换能够躲开一般的类型检查，所以你在使用时必须格外小心，确保函数参数类型是正确的。

在这个例子里，回调函数比较两个值。查找函数向比较函数传递两个指向需要进行比较的值的指针，并检查比较函数的返回值。例如：零表示相等的值，现在查找函数就与类型无关，因为它本身并不执行实际的比较。确实，调用者必须编写必需的比较函数，但这样做是很容易的，因为调用者知道链表中所包含的值的类型。如果使用几个分别包含不同类型值的链表，为每种类型编写一个比较函数就允许单个查找函数作用于所有类型的链表。

程序段01 是类型无关的查找函数的一种实现方法。 注意函数的第 3 个参数是一个函数指针。这个参数用一个完整的原型进行声明。同时注意虽然函数绝不会修改参数 node 所指向的任何节点，但 node 并未被声明为 const 。如果 node 被声明为 const，函数将不得不返回一个const结果，这将限制调用程序，它便无法修改查找函数所找到的节点。

#include

#include "node.h"

Node *

search_list( Node *node, void const *value, int (*compare)( void const *, void const *) )

{

while (node!=NULL){

if(compare(&node->value, value)==0)

break;

node=node->link;

}

return node;

}

指向值参数的指针和 &node->value 被传递给比较函数。后者是我们当前所检查的节点值。

在一个特定的链表中进行查找时，用户需要编写一个适当的比较函数，并把指向该函数的指针和指向需要查找的值的指针传递给查找函数下面是一个比较函数，它用于在一个整数链表中进行查找。

int

compare_ints( void const *a, void const *b )

{

if( *(int *)a == *(int *)b )

return 0;

else

return 1;

}

这个函数像下面这样使用：

desired_node = search_list ( root, &desired_value, compare_ints );

注意强制类型转换：比较函数的参数必须声明为 void * 以匹配查找函数的原型，然后它们再强制转换为 int * 类型，用于比较整型值。

如果你希望在一个字符串链表中进行查找，下面的代码可以完成这项任务:

#include

...

desired_node = search_list( root, "desired_value", strcmp);

碰巧，库函数 strcmp 所执行的比较和我们需要的完全一样，不过有些编译器会发出警告信息，因为它的参数被声明为 char * 而不是

void *。

（二）转移表

转换表最好用个例子来解释。下面的代码段取自一个程序，它用于实现一个袖珍式计算器。程序的其他部分已经读入两个数（op1和op2）和一个操作数(oper)。下面的代码对操作符进行测试，然后决定调用哪个函数。

switch( oper ){

case ADD:

result = add( op1, op2);

break;

case SUB:

result = sub( op1, op2);

break;

case MUL:

result = mul( op1, op2);

break;

case DIV:

result = div( op1, op2);

break;

......

对于一个新奇的具有上百个操作符的计算器，这条switch语句将非常长。

为什么要调用函数来执行这些操作呢？ 把具体操作和选择操作的代码分开是一种良好的设计方法，更为复杂的操作将肯定以独立的函数来实现，因为它们的长度可能很长。但即使是简单的操作也可能具有副作用，例如保存一个常量值用于以后的操作。

为了使用 switch 语句，表示操作符的代码必须是整数。如果它们是从零开始连续的整数，我们可以使用转换表来实现相同的任务。转换表就是一个函数指针数组。

创建一个转换表需要两个步骤。首先，声明并初始化一个函数指针数组。唯一需要留心之处就是确保这些函数的原型出现在这个数组的声明之前。

double add （double，double）；

double sub （double，double）；

double mul （double，double）；

double div （double，double）；

......

double （ *oper_func[] ）( double, double)={

add,sub,mul,div,...

};

初始化列表中各个函数名的正确顺序取决于程序中用于表示每个操作符的整型代码。这个例子假定ADD是0 ，SUB是1，MUL是2，依次类推。

第 2 个步骤是用下面这条语句替换前面整条 switch 语句！

result = oper_func[ oper ]( op1,op2 );

oper从数组中选择正确的函数指针，而函数调用操作符执行这个函数。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/hejianhua/archive/2008/11/07/3249586.aspx