void Func(char *s);//函数原型-------A void (*pFunc) (char *);//函数指针 一般化的，为了简化函数指针类型的变量的定义，提高可读性，我们把函数指针自定义一下 typedef void (*pcb) (char *); -------------------------------- void GetCallBack(pcb callback){} vodi fCallBack(char *s){}----------A//与上面的A等同 GetCallBack(fCallBack);   ================================================================================ 回调函数实例
typedef void (*f1) ();// 为函数指针声明类型定义
void (*p) (); //p是指向某函数的指针
void func1()
{

printf("From func1(), Hello World!/n");
} void caller(void(*ptrfunc1)())
{
ptrfunc1();
} //typedef bool (*f2) (int *);// 为函数指针声明类型定义
//bool (*q) (int *); //p是指向某函数的指针 bool func2(int* t_i)
{

printf("From func2() = %d, Hello World!/n", (*t_i)++);
return true;
} void caller2(bool (*ptrfunc2)(int *), int * i)
{
ptrfunc2(i);
}
int main(int argc, char* argv[])
{
printf("From main(), Hello World!/n");
printf("/n"); //无参数调用
p = func1;
caller(p); //有参数调用
int i = 0;
for (int j = 0; j < 10; j++)
{
caller2(func2, &i); /
} //有参数调用第二次
i = 0;
//q = func2;
//caller2(q, &i);
printf("/n");
printf("From main(), Hello World!/n");
getchar(); return 0;
}   *************************************************************
关于回调函数的例子 知识要点：
1、指向函数的指针如： int (*p)(int )
2、回调函数可以调用用户自定义的函数，但自定义函数的参数
不可变。
**************************************************************/
#include int callbackfn(int (*p)(int ), int data )//定义回调函数
{
    p(data);
    return 0;
} int myfn(int a);//用户自定义函数1；
int yourfn(int b);//用户自定义函数2； int main( )
{
    callbackfn(myfn,1111);//回调函数调用用户函数1；
    callbackfn(yourfn,2222);//回调函数调用用户函数2；
    return 0;
}
int myfn( int a )
{
    printf("我的函数%i/n",a);
    return a;
} int yourfn(int b)
{
    printf("你的函数%i/n",b);
    return b;
}   用c写的一个回调函数例子，对回调函数的理解有所帮助。
#include
#include typedef int (CALLBACK* GetVersionFun)(char* sName, int nLength);
BOOL CallerFun(GetVersionFun pGetVersion, char* sVersion, int nLength); int CALLBACK GetVersionStr(char* sName, int nLength)
{
     printf("sName0 = %s/r/n", sName);
     memset(sName, 0x00, nLength);
     strcpy(sName, "wo hao xiang ni!");
     return 0;
}
int main()
{
     char buff[32] = {0};
     strcpy(buff, "ni xiang wo ma?");
     CallerFun(GetVersionStr, buff, 32);           printf("sName1 = %s/r/n",buff);
     return 0;
}
BOOL CallerFun(GetVersionFun pGetVersion, char* sVersion, int nLength)
{
     pGetVersion(sVersion, nLength);
     return true;
}   基于C编程的回调函数
    回调函数是基于C编程的Windows SDK的技术，不是针对C++的，程序员可以将一个C函数直接作为回 调函数，但是如果试图直接使用C++的成员函数作为回调函数将发生错误，甚至编译就不能通过。
    分析原因：
    普通的C++成员函数都隐含了一个传递函数作为参数，亦即“this”指针，C++通过传递一个指向自 身的指针给其成员函数从而实现程序函数可以访问C++的数据成员。这也可以理解为什么C++类的多个实 例可以共享成员函数但是确有不同的数据成员。由于this指针的作用，使得将一个CALLBACK型的成员函 数作为回调函数安装时就会因为隐含的this指针使得函数参数个数不匹配，从而导致回调函数安装失败
    解决方案：
    一,不使用成员函数，直接使用普通C函数，为了实现在C函数中可以访问类的成员变量，可以使用友 元操作符(friend)，在C++中将该C函数说明为类的友元即可。这种处理机制与普通的C编程中使用回调函 数一样。
    二,使用静态成员函数，静态成员函数不使用this指针作为隐含参数，这样就可以作为回调函数了。 静态成员函数具有两大特点：其一，可以在没有类实例的情况下使用；其二，只能访问静态成员变量和 静态成员函数，不能访问非静态成员变量和非静态成员函数。由于在C++中使用类成员函数作为回调函数 的目的就是为了访问所有的成员变量和成员函数，如果作不到这一点将不具有实际意义。我们通过使用 静态成员函数对非静态成员函数包装的办法来解决问题。类实例可以通过附加参数或全局变量的方式的 方式传递到静态成员函数中。分别举例如下：
    1，参数传递的方式
   #include    
   class TClassA
   {
   public:
      void Display(const char* text) { cout << text << endl; };
      static void Wrapper_To_Call_Display(void* pt2Object, char* text);
      // more....
   };
   // 静态包装函数，能够调用成员函数Display(),本身做为回调函数来使用
   void TClassA::Wrapper_To_Call_Display(void* pt2Object, char* string)
   {
       // 显式类型转换
       TClassA* mySelf = (TClassA*) pt2Object;
       // 调用普通成员函数
       mySelf->Display(string);
   }
   // 回调函数的宿主,在这里回调用函数被使用
   void DoItA(void* pt2Object, void (*pt2Function)(void* pt2Object, char* text))
   {
      // 使用回调函数 [Page]
      pt2Function(pt2Object, "hi, i’m calling back using a argument ;-)");  
   }
   // 执行示例
   void Callback_Using_Argument()
   {
      TClassA objA;
      DoItA((void*) &objA, TClassA::Wrapper_To_Call_Display);
   }
2，全局变量的方式
   #include    
   void* pt2Object;        // 全局变量,可以指向任意对象
   class TClassB
   {
   public:
      void Display(const char* text) { cout << text << endl; };
      static void Wrapper_To_Call_Display(char* text);
   };
   // 静态的包装函数
   void TClassB::Wrapper_To_Call_Display(char* string)
   {
       //需要保证全局变量值的正确性
       TClassB* mySelf = (TClassB*) pt2Object;
       mySelf->Display(string);
   }
   // 回调用函数的宿主,在这里回调用函数被使用
   void DoItB(void (*pt2Function)(char* text))
   {
   
      pt2Function("hi, i’m calling back using a global ;-)");   // make callback
   }
   // 执行示例
   void Callback_Using_Global()
   {
      TClassB objB;  
      pt2Object = (void*) &objB;
      DoItB(TClassB::Wrapper_To_Call_Display);
   }
    注意：通过上面两种方法的比较可以看出，第2种方法中静态包装函数可以和普通成员函数保持签名 一致，当回调函数的宿主接口不能改变时，这种方法特别有用。但因为使用了全局变量，也不是一个好 的设计。