回调函数就是一个通过函数指针调用的函数。假如把A函数的指针当作参数传给B函数,然后在B函数中通过A函数传进来的这个指针调用A函数，那么就是回调机制。A函数就是回调函数，而通常情况下，A函数是在系统符合你设定的条件下自动执行。

使用回调函数可以改善软件的结构，提供软件的复用性。

函数指针是一个指针，只是这个指针不像普通的指针指向一个变量，此时它指向的是一个函数，也就是它存储的是一个函数的指针。

C++的类成员函数不能像普通函数那样用于回调，因为每个成员函数都需要有一个对象实例去调用它。通常情况下，要实现成员函数作为回调函数，一种常用的方法就是把该成员函数设计为静态成员函数。

#include

typedef int(*Fun11)(int, int);
typedef float(*Fun12)(float, float);

int min(int a, int b)
{
?return a < b ? a : b;;
}

float max(float a, float b)
{
?return a > b ? a : b;
}

int test1()
{
?Fun11 pFun1 = NULL;
?pFun1 = &min;
?int ret1 = pFun1(-1, 2);
?std::cout<<"min value is: "<

?Fun12 pFun2 = NULL;
?pFun2 = &max;
?float ret2 = pFun2(3.4, -2.2);
?std::cout<<"max value is: "<

?return 0;
}

typedef void(*Fun2)(void*);

class CallBack;
class CallBackTest;

class CallBackTest {
public:
?CallBackTest() {}
?~CallBackTest() {}

?void registerProc(Fun2 fptr, void* arg = NULL)
?{
? m_fptr = fptr;
? if (arg != NULL) {
? ?m_arg = arg;
? }
?}

?void doCallBack()
?{
? m_fptr(m_arg);
?}

private:
?Fun2 m_fptr;
?void* m_arg;
};

class CallBack {
public:
?CallBack(CallBackTest* t) : a(2)
?{
? if (t) {
? ?t->registerProc((Fun2)display, this);
? }
?}

?~CallBack() {}

?static void display(void* _this = NULL)
?{
? if (!_this) {
? ?return;
? }

? CallBack* pc = (CallBack*)_this;
? pc->a++;
? std::cout<<"a is "<a<?}

private:
?int a;
};

int test2()
{
?//http://www.360doc.com/content/14/0825/13/15077656_404487615.shtml
?CallBackTest* cbt = new CallBackTest();
?CallBack* cb = new CallBack(cbt);
?cbt->doCallBack();

?return 0;
}

void callback31()
{
?std::cout<<"this a callback function 31"<}

int callback32(int num)
{
?std::cout<<"this input param value is: "<

?return 0;
}

void Caller31(void (*ptr)())
{
?(*ptr)();
}

void Caller32(int n, int (*ptr)(int))
{
?(*ptr)(n);
}

int test3()
{
?Caller31(callback31);
?Caller32(32, callback32);

?return 0;
}

int main()
{
?test1();
?test2();
?test3();
?
?return 0;
}