无论是用什么编程语言编写应用程序，都会涉及到函数调用之间的问题。而调用过程可以分为两种，一种是主动请求调用，一种是被动等待调用。这也就是我们常说的调用与回调。下面我将说明DotNet（C#）与ISO C++关于函数回调的实现分析。
一、DotNet（C#）函数回调。
在DotNet中实现函数调用是通过委托（delegate）实现的，首先你要声明委托原型：delegate void Notify( int newValue );
这样就声明了一个委托，那到底什么是委托呢？其实委托就是一个回调函数（更确切的说委托是一个安全的函数指针）。当需要回调的时候。可以调用委托的成员函数 Invoke 就可以实现调用你设置的回调函数。这时Invoke会自动根据你声明的委托形式进行调用。在这里我们举一个例子，压力计、报警器的例子：
当压力计的压力指数变化的时候，报警器会报警，并打印出变化的压力值。代码如下
using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication2
{
// 这里声明委托
public delegate void Notify( int newValue );
// 压力计
class Piezometer
{
// 压力值
private int m_PressureNumber;
public int PressureNumber
{
get
{
// 返回当前压力值
return this.m_PressureNumber;
}
set
{
// 设置新的压力值
this.m_PressureNumber = value;
// 判断是否有人注册该事件，如果有就调用并传入新的压力值。
if (OnPressureChanged != null)
{
// 这里就是DotNet框架实现的委托好处，它可以根据
// 声明的形式自动匹配调用的参数表和返回值。
// 调用回调事件，将新的压力值传入
OnPressureChanged.Invoke(value);
}
}
}
// 声明一个事件，当压力值变化的时候触发该事件
public event Notify OnPressureChanged;
}
// 报警器
class Alerter
{
// 设置监听的压力计
public void Listen(Piezometer piezometer)
{
// 注册压力计压力变化事件
piezometer.OnPressureChanged += new Notify(OnChanged);
}
// 这里就是压力计变化后调用的函数
public void OnChanged(int newValue)
{
// 打印出新的压力值
Console.WriteLine(string.Format(“New PressureNumber is {0}.“, newValue));
}
}
class Program
{
static void Main(string[] args)
{
Alerter alerter = new Alerter();
Piezometer piezometer = new Piezometer();
// 安装压力计，进行监听
alerter.Listen(piezometer);
// 设置新的压力值，报警器就会打印出新的压力值。
piezometer.PressureNumber = 10;
}
}
}
根据上面的代码我们可以实现自己的自定义事件。（感叹：DotNet框架真是太便利了，声明委托之后，委托的调用方法会自动变成声明的形式。C++就不支持这种操作。下面我会讲一下C++的实现方法。）
在这里我们用Reflector反编译一下Delegate类，该类是委托类型的基类。然而，只有系统和编译器可以显式地从 Delegate 类或 MulticastDelegate 类派生。此外，还不允许从委托类型派生新类型。Delegate 类不是委托类型，该类用于派生委托类型。而我们实现的都是MulticastDelegate派生类型，这样就可以产生一个委托多播的类型。最基本的实现是
protected virtual object DynamicInvokeImpl(object[] args)
{
RuntimeMethodHandle methodHandle = new RuntimeMethodHandle(this.GetInvokeMethod());
RuntimeMethodInfo methodBase = (RuntimeMethodInfo) RuntimeType.GetMethodBase(Type.GetTypeHandle(this), methodHandle);
return methodBase.Invoke(this, BindingFlags.Default, null, args, null, true);
}
当委托被调用时会产生一个运行时方法对象。并通过运行时对象调用
[MethodImpl(MethodImplOptions.InternalCall), DebuggerStepThrough, DebuggerHidden]
private extern object _InvokeMethodFast(object target, object[] arguments, ref SignatureStruct sig, MethodAttributes methodAttributes, RuntimeTypeHandle typeOwner);
通知VM进行系统执行方法体。而在多播委托里包含一个_invocationList实现了保存多个委托，使之内部可以循环调用进行广播。
二、ISO C++事件回调。
注意这里我指的是ISO C++实现的回调机制，他不依赖于任何操作系统。C++作为C语言的扩展（C++的Fans不要生气，毕竟C++在企业级快速开发比Java、DotNet要逊色一些），还是举上面的例子实现代码如下：
#ifndef __EVENT_HPP
#define __EVENT_HPP
#include ＜vector＞
using std::vector;
class EmptyType {};
template＜ typename EventFunctionPtrType ＞
class EventObject
{
public:
EventObject() :
ObjectPtr( NULL ),
EventFunctionPointerPtr( NULL )
{
}
public:
EmptyType* ObjectPtr;
EventFunctionPtrType* EventFunctionPointerPtr;
};
template＜ typename EventFunctionPtrType ＞
class Event
{
public:
typedef vector＜ EventObject＜ EventFunctionPtrType ＞ ＞ EventList;
typedef typename vector＜ EventObject＜ EventFunctionPtrType ＞ ＞::iterator EventIterator;
public:
template＜ typename ObjectType,
typename MemeberFunctionPtrType ＞
static EventObject＜ EventFunctionPtrType ＞ EventBind( ObjectType* pObj, MemeberFunctionPtrType memberFunctionPtr )
{
MemeberFunctionPtrType* pf = new MemeberFunctionPtrType;
*pf = memberFunctionPtr;
EventObject＜ EventFunctionPtrType ＞ eventObj;
eventObj.ObjectPtr = (EmptyType*)pObj;
eventObj.EventFunctionPointerPtr = (EventFunctionPtrType*)pf;
return eventObj;
}
public:
Event()
{
}
virtual ~Event()
{
EventIterator iter;
for( iter = m_EventList.begin();
iter != m_EventList.end();
++iter )
{
if( iter-＞EventFunctionPointerPtr != NULL )
delete iter-＞EventFunctionPointerPtr;
}
}
virtual void operator+=( EventObject＜ EventFunctionPtrType ＞& eventObj )
{
bool hasTheEvent = false;
EventIterator iter;
for( iter = m_EventList.begin();
iter != m_EventList.end();
++iter )
{
if( iter-＞ObjectPtr == eventObj.ObjectPtr &&
iter-＞EventFunctionPointerPtr == eventObj.EventFunctionPointerPtr )
{
hasTheEvent = true;
break;
}
}
if( !hasTheEvent )
m_EventList.push_back( eventObj );
}
virtual void operator-=( EventObject＜ EventFunctionPtrType ＞& eventObj )
{
EventIterator iter;
for( iter = m_EventList.begin();
iter != m_EventList.end();
++iter )
{
if( iter-＞ObjectPtr == eventObj.ObjectPtr &&
iter-＞EventFunctionPointerPtr == eventObj.EventFunctionPointerPtr )
{
if( iter-＞EventFunctionPointerPtr != NULL )
delete iter-＞EventFunctionPointerPtr;
m_EventList.erase( iter );
break;
}
}
}
public:
EventList m_EventList;
};
typedef EmptyType EventDelegater;
#endif // __EVENT_HPP
example.cpp
1// EventTest.cpp : 定义控制台应用程序的入口点。
2//
3
4#include “stdafx.h“
5#include “event.hpp“
6
7using std::cout;
8using std::endl;
9
10// 声明事件代理模型（类成员函数指针）
11typedef void ( EventDelegater::*NumberChanged )( int );
12
13// 压力计
14class Piezometer
15{
16public:
17 Piezometer();
18
19public:
20 void SetPressureNumber( int newVal ); // 设置压力值
21 int GetPressureNumber(); // 获取压力值
22
23 // 压力值变化事件
24 Event＜ NumberChanged ＞ OnPressureChanged;
25
26private:
27 int m_PressureNumber;
28};
29
30Piezometer::Piezometer() : m_PressureNumber( 0 )
31{
32}
33
34void Piezometer::SetPressureNumber( int newVal )
35{
36 m_PressureNumber = newVal;
37
38 // 判断事件列表是否为空
39 if( !OnPressureChanged.m_EventList.empty() )
40 {
41 // 循环事件列表
42 Event＜ NumberChanged ＞::EventIterator iter;
43 for( iter = OnPressureChanged.m_EventList.begin();
44 iter != OnPressureChanged.m_EventList.end();
45 ++iter )
46 {
47 // 调用事件
48 ((iter-＞ObjectPtr)-＞*(*iter-＞EventFunctionPointerPtr))( newVal );
49 }
50 }
51}
52
53int Piezometer::GetPressureNumber()
54{
55 return m_PressureNumber;
56}
57
58// 报警器
59class Alerter
60{
61public:
62 void Listen( Piezometer* );
63 void OnChanged( int newVal );
64};
65
66void Alerter::Listen( Piezometer* pObj )
67{
68 // 绑定成员函数到事件
69 pObj-＞OnPressureChanged += Event＜ NumberChanged ＞::EventBind( this, Alerter::OnChanged );
70}
71
72void Alerter::OnChanged( int newVal )
73{
74 cout ＜＜ “New Pressure Number is “ ＜＜ newVal ＜＜ “.“ ＜＜ endl;
75}
76
77int _tmain(int argc, _TCHAR* argv[])
78{
79 Piezometer piezometer;
80 Alerter alerter;
81
82 alerter.Listen( &piezometer );
83 piezometer.SetPressureNumber( 10 );
84
85 return 0;
86}
87
88
上面的做法完全是按照面向对象设计的，这种函数回调方法并不是静态函数回调，而是对象方法回调。C++这种做法没有DotNet使用委托来的方便，因为C++回调类成员函数指针是不能转换为 void* ，必须转换成指针的指针，而且要引用一个EmptyType类，EmptyType类的更多应用可以参见《C++设计新思维》。
回调成员函数是C++实现事件机制的方法之一，实现调用是通过 ((iter-＞ObjectPtr)-＞*(*iter-＞EventFunctionPointerPtr))( newVal ); 语句实现的，我在这里讲一下大体思路 class Event 实现了事件列表以及内存指针释放的功能，这样就可以实现事件的多播。class EventObject 实现了对象指针与该对象实现的成员函数的配对（当然也可以用STL中的pair），我们是通过C++操作符.*或是-＞*实现调用成员函数指针。iter-＞ObjectPtr保存了对象指针，iter-＞EventFunctionPointerPtr保存了对象成员函数指针的指针。因为C++不支持将一个类成员函数的指针转换成另一个类的成员函数指针，所以我在这里实现一个EmptyType类用于委托声明和指针转换。
C++操作符.*或是-＞*实现调用成员函数指针，和回调静态函数有什么却别呢？
面向对象是将一组方法和方法相关的数据绑定起来，当类成员函数调用的时候可以访问该类的成员变量，而访问变量是通过向成员函数传入该类的this指针，当然这个不用我们去实现，C++内部已经实现。在成员方法被调用时，该类的this指针会传到寄存器ECX。这样成员函数就可以通过ECX访问到成员变量了：
push 参数
mov ecx, this
call 成员函数
这样就实现了成员函数的调用，而静态函数不涉及到成员函数，所以函数内部所用到的数据都是通过 push 参数实现的。
三、Windows实现事件机制。
使用Windows API实现事件机制主要是通过消息队列，通过GetMessage、PeekMessage创建消息循环，并调用DispatchMessage分发消息。这种实现事件机制，基本上是通过回调函数实现的，而不是通过回调成员函数实现的。具体方法可以参见MSDN。
写在最后：
我个人比较喜欢第二种做法，原因如下：不依赖于操作系统，与平台无关。而且面向对象，在面向对象项目中比静态回调函数更适合。效率高，当使用Windows事件机制必须要创建窗体，使用消息循环，效率肯定比回调函数指针要低。但对于多线程没有Windows事件机制方便（一个线程要通知另一个线程，或是进程间通信无法实现，因为其始终在一个线程执行）。
[文章来源：