| 编译器 | 选项 | int | DataPtr | CodePtr | Single | Multi | Virtual | Unknown |
| MSVC | | 4 | 4 | 4 | 4 | 8 | 12 | 16 |
| MSVC | /vmg | 4 | 4 | 4 | 16# | 16# | 16# | 16 |
| MSVC | /vmg /vmm | 4 | 4 | 4 | 8# | 8# | – | 8# |
| Intel_IA32 | | 4 | 4 | 4 | 4 | 8 | 12 | 12 |
| Intel_IA32 | /vmg /vmm | 4 | 4 | 4 | 4 | 8 | – | 8 |
| Intel_Itanium | | 4 | 8 | 8 | 8 | 12 | 20 | 20 |
| G++ | | 4 | 4 | 4 | 8 | 8 | 8 | 8 |
| Comeau | | 4 | 4 | 4 | 8 | 8 | 8 | 8 |
| DMC | | 4 | 4 | 4 | 4 | 4 | 4 | 4 |
| BCC32 | | 4 | 4 | 4 | 12 | 12 | 12 | 12 |
| BCC32 | /Vmd | 4 | 4 | 4 | 4 | 8 | 12 | 12 |
| WCL386 | | 4 | 4 | 4 | 12 | 12 | 12 | 12 |
| CodeWarrior | | 4 | 4 | 4 | 12 | 12 | 12 | 12 |
| XLC | | 4 | 8 | 8 | 20 | 20 | 20 | 20 |
| DMC | small | 2 | 2 | 2 | 2 | 2 | 2 | 2 |
| DMC | medium | 2 | 2 | 4 | 4 | 4 | 4 | 4 |
| WCL | small | 2 | 2 | 2 | 6 | 6 | 6 | 6 |
| WCL | compact | 2 | 4 | 2 | 6 | 6 | 6 | 6 |
| WCL | medium | 2 | 2 | 4 | 8 | 8 | 8 | 8 |
| WCL | large | 2 | 4 | 4 | 8 | 8 | 8 | 8 |
| 注： # 表示使用 __single/__multi/__virtual_inheritance关键字的时候代表 4、 8或 12 。 这些编译器是 Microsoft Visual C++ 4.0 to 7.1 (.NET 2003), GNU G++ 3.2 (MingW binaries, http://www.mingw.org/), Borland BCB 5.1 (http://www.borland.com/), Open Watcom (WCL) 1.2 (http://www.openwatcom.org/), Digital Mars (DMC) 8.38n (http://www.digitalmars.com/), Intel C++ 8.0 for Windows IA-32, Intel C++ 8.0 for Itanium, (http://www.intel.com/), IBM XLC for AIX (Power, PowerPC), Metrowerks Code Warrior 9.1 for Windows (http://www.metrowerks.com/), 和 Comeau C++ 4.3 (http://www.comeaucomputing.com/). Comeau的数据是在它支持的 32位平台（ x86, Alpha, SPARC等）上得出的。 16位的编译器的数据在四种 DOS配置（ tiny, compact, medium, 和 large）下测试得出，用来显示各种不同代码和数据指针的大小。 MSVC在 /vmg的选项下进行了测试，用来显示“成员指针的全部特性”。（如果你拥有在列表中没有出现的编译器，请告知我。非 x86处理机下的编译器测试结果有独特的价值。） |
看 着表中的数据，你是不是觉得很惊奇？你可以清楚地看到编写一段在一些环境中可以运行而在另一些编译器中不能运行的代码是很容易的。不同的编译器之间，它们 的内部实现显然是有很大差别的；事实上，我认为编译器在实现语言的其他特性上并没有这样明显的差别。对实现的细节进行研究你会发现一些奇怪的问题。
一般，编译器采取最差的，而且一直使用最普通的形式。比如对于下面这个结构：
struct {
FunctionPointer m_func_address;
int m_delta;
int m_vtable_index;
} ;
struct {
int m_delta;
int m_vtable_index;
FunctionPointer m_func_address;
};
struct {
int m_vtable_index;
FunctionPointer m_func_address;
int m_delta;
};
struct {
FunctionPointer m_func_address;
int m_delta;
int m_vtordisp;
int m_vtable_index;
} ;
struct {
FunctionPointer m_func_address;
int m_vtable_index;
int m_delta;
int m_vtordisp;
};
struct {
union {
FunctionPointer m_func_address;
int m_vtable_index_2;
};
int m_delta;
};
|
对于几乎所有的编译器， delta和 vindex用来调整传递给函数的 this指针，比如 Borland的计算方法是：
adjustedthis = *(this + vindex -1) + delta
adjustedthis = this + delta
|
（其中，“ *”是提取该地址中的数值， adjustedthis是调整后的 this指针——译者注）
Borland使用了一个优化方法：如果这个类是单一继承的，编译器就会知道delta和vindex的值是0，所以它就可以跳过上面的计算方法。
GNU编译器使用了一个奇怪的优化方法。可以清楚地看到，对于多重继承来说，你必须查看 vtable（虚拟函数表）以获得 voffset（虚拟函数偏移地址）来计算 this指针。当你做这些事情的时候，你可能也把函数指针保存在 vtable中。通过这些工作，编译器将 m_func_address和 m_vtable_index合二为一（即放在一个 union中），编译器区别这两个变量的方法是使函数指针（ m_func_address）的值除以 2后结果为偶数，而虚拟函数表索引 (m_vtable_index_2)除以 2后结果为奇数。它们的计算方法是：
adjustedthis = this + delta
if (funcadr & 1)
call (* ( *delta + (vindex+1)/2) + 4)
else
call funcadr
|
（其中， funcadr 是函数地址除以 2得出的结果。——译者注）
Inter的 Itanium编译器（但不是它们的 x86编译器）对虚拟继承（ virtual inheritance）的情况也使用了 unknown_inheritance结构，所以，一个虚拟继承的指针有 20字节大小，而不是想象中的 16字节。
struct {
FunctionPointer m_func_address;
int m_delta;
int m_vtable_index;
int m_vtordisp;
};
|
我不能保证 Comeau C++使用的是和 GNU相同的技术，也不能保证它们是否使用 short代替 int使这种虚拟函数指针的结构的大小缩小至 8个字节。最近发布的 Comeau C++版本为了兼容微软的编译器也使用了微软的编译器关键字（我想它也只是忽略这些关键字而不对它们进行实质的相关处理罢了）。
Digital Mars编译器（即最初的 Zortech C++到后来的 Symantec C++）使用了一种不同的优化方法。对单一继承类来说，一个成员函数指针仅仅是这个函数的地址。但涉及到更复杂的继承时，这个成员函数指针指向一个形式转换函数（ thunk function） ，这个函数可以实现对 this指 针的必要调整并可用来调用实际的成员函数。每当涉及到多重继承的时候，每一个成员函数的指针都会有这样一个形式转换函数，这对函数调用来说是非常有效的。 但是这意味着，当使用多重继承的时候，子类的成员函数指针向基类成员函数指针的转换就会不起作用了。可见，这种编译器对编译代码的要求比其他的编译器要严 格得多。
很多嵌入式系统的编译器不允许多重继承。这样，这些编译器就避免了可能出现的问题：一个成员函数指针就是一个带有隐藏 this指针参数的普通函数指针。
微软 “smallest for class”方法的问题
微软的编译器使用了和 Borland相似的优化方法。它们都使单一继承的情况具有最优的效率。但不像 Borland，微软在缺省条件下成员函数指针省略了值为 0的指针入口（ entry），我称这种技术为“ smallest for class”方法：对单一继承类来说，一个成员函数指针仅保存了函数的地址（ m_func_address），所以它有 4字节长。而对于多重继承类来说，由于用到了偏移地址（ m_delta），所以它有 8字节长。对虚拟继承，会用到 12个字节。这种方法确实节省空间，但也有其它的问题。
首先，将一个成员函数指针在子类和基类之间进行转化会改变指针的大小！因此，信息是会丢失的。其次，当一个成员函数指针在它的类定义之前声明的时候，编译器必须算出要分配给这个指针多少空间，但是这样做是不安全的，因为在定义之前编译器不可能知道这个类的继承方式。对 Intel C++和早期的微软编译器来说，编译器仅仅对指针的大小进行猜测，一旦在源文件中猜测错误，你的程序会在运行时莫名其妙地崩溃。所以，微软的编译器中增加了一些保留字： __single_inheritance, __multiple_inheritance,和 __virtual_inheritance，并增设了一些编译器开关（ compiler switch），如 /vmg，让所有的成员函数指针有相同的大小，而对原本个头小的成员函数指针的空余部分用 0填充。 Borland编译器也增加了一些编译器开关，但没有增加新的关键字。 Intel的编译器可以识别 Microsoft增加的那些关键字，但它在能够找到类的定义的情况下会对这些关键字不做处理。
对于 MSVC来说，编译器需要知道类的 vtable在哪儿；通常就会有一个 this指针的偏移量（ vtordisp），这个值对所有这个类中的成员函数来说是不变的，但对每个类来说会是不同的。对于 MSVC，经调整过的 this指针是在原 this指针的基础上经过下面的计算得出的：
if (vindex=0)
adjustedthis = this + delta
else
adjustedthis = this + delta + vtordisp + *(*(this + vtordisp) + vindex)
|
在虚拟继承的情况下， vtordisp的值并不保存在 __virtual_inheritance指针中，而是在发现函数调用的代码时，编译器才将其相应的汇编代码“嵌”进去。但是对于未知类型的继承，编译器需要尽可能地通过读代码确定它的继承类型，所以，编译器将虚拟继承指针（ virtual inheritance pointer）分为两类（ __virtual_inheritance和 __unknown_inheritance）。
理论上，所有的编译器设计者应该在 MFP（成员函数指针）的实现上有所变革和突破。但在实际上，这是行不通的，因为这使现在编写的大量代码都需要改变。微软曾发表了一篇非常古老的文章（ http://msdn.microsoft.com/archive/en-us/dnarvc/html/jangrayhood.asp）来解释 Visual C++运作的实现细节。这篇文章是 Jan Gray写的，他曾在 1990年设计了 Microsoft C++的对象模型。尽管这篇文章发表于 1994年，但这篇文章仍然很重要——这意味着 C++的对象模型在长达 15年的时间里（ 1990年到 2004年）没有丝毫改变。
现在，我想你对成员函数指针的事情已经知道得太多了。要点是什么？我已为你建立了一个规则。虽然各种编译器的在这方面的实现方法有很大的不同，但是也有一些有用的共同点：不管对哪种形式的类，调用一个成员函数指针生成的汇编语言代码是完全相同的。有一种特例是使用了“ smallest for class”技术的非标准的编译器，即使是这种情况，差别也是很微小的。这个事实可以让我们继续探索怎样去建立高性能的委托（ delegate）。
成员函数指针与高性能的C++委托（下篇）
Member Function Pointers and the Fastest Possible C++ Delegates
撰文： Don Clugston
翻译：周翔
（接中篇）
委托（delegate ）
和成员函数指针不同，你不难发现委托的用处。最重要的，使用委托可以很容易地实现一个 Subject/Observer设计模式的改进版 [GoF, p. 293]。 Observer（观察者）模式显然在 GUI中有很多的应用，但我发现它对应用程序核心的设计也有很大的作用。委托也可用来实现策略（ Strategy） [GoF, p. 315]和状态（ State） [GoF, p. 305]模式。
现在，我来说明一个事实，委托和成员函数指针相比并不仅仅是好用，而且比成员函数指针简单得多！既然所有的 .NET语言都实现了委托，你可能会猜想如此高层的概念在汇编代码中并不好实现。但事实并不是这样：委托的实现确实是一个底层的概念，而且就像普通的函数调用一样简单（并且很高效）。一个 C++委托只需要包含一个 this指针和一个简单的函数指针就够了。当你建立一个委托时，你提供这个委托一个 this指针，并向它指明需要调用哪一个函数。编译器可以在建立委托时计算出调整 this指针需要的偏移量。这样在使用委托的时候，编译器就什么事情都不用做了。这一点更好的是，编译器可以在编译时就可以完成全部这些工作，这样的话，委托的处理对编译器来说可以说是微不足道的工作了。在 x86系统下将委托处理成的汇编代码就应该是这么简单：
mov ecx, [this]
call [pfunc]
但是，在标准 C++中却不能生成如此高效的代码。 Borland为了解决委托的问题在它的 C++编译器中加入了一个新的关键字（ __closure） ,用来通过简洁的语法生成优化的代码。 GNU编译器也对语言进行了扩展，但和 Borland的编译器不兼容。如果你使用了这两种语言扩展中的一种，你就会限制自己只使用一个厂家的编译器。而如果你仍然遵循标准 C++的规则，你仍然可以实现委托，但实现的委托就不会是那么高效了。
有趣的是，在 C#和其他 .NET语言中，执行一个委托的时间要比一个函数调用慢 8倍 （参见 http://msdn.microsoft.com/library/en-us/dndotnet/html/fastmanagedcode.asp）。我猜测这可能是垃圾收集和 .NET安全检查的需要。最近，微软将“统一事件模型（ unified event model）”加入到 Visual C++中，随着这个模型的加入，增加了 __event、 __raise、 __hook、 __unhook、 event_source和 event_receiver等一些关键字。坦白地说，我对加入的这些特性很反感，因为这是完全不符合标准的，这些语法是丑陋的，因为它们使这种 C++不像 C++，并且会生成一堆执行效率极低的代码。
解决这个问题的推动力：对高效委托（ fast delegate）的迫切需求
使用标准 C++实现委托有一个过度臃肿的症状。大多数的实现方法使用的是同一种思路。这些方法的基本观点是将成员函数指针看成委托��但这样的指针只能被一个单独的类使用。为了避免这种局限，你需要间接地使用另一种思路：你可以使用模版为每一个类建立一个“成员函数调用器（ member function invoker）”。委托包含了 this指针和一个指向调用器（ invoker）的指针，并且需要在堆上为成员函数调用器分配空间。
对于这种方案已经有很多种实现，包括在 CodeProject上的实现方案。各种实现在复杂性上、语法（比如，有的和 C#的语法很接近）上、一般性上有所不同。最具权威的一个实现是 boost::function。最近，它已经被采用作为下一个发布的 C++标准版本中的一部分 [Sutter1]。希望它能够被广泛地使用。
就像传统的委托实现方法一样，我同样发觉这种方法并不十分另人满意。虽然它提供了大家所期望的功能，但是会混淆一个潜在的问题：人们缺乏对一个语言的底层的构造。 “成员函数调用器”的代码对几乎所有的类都是一样的，在所有平台上都出现这种情况是令人沮丧的。毕竟，堆被用上了。但在一些应用场合下，这种新的方法仍然无法被接受。
我做的一个项目是离散事件模拟器，它的核心是一个事件调度程序，用来调用被模拟的对象的成员函数。大多数成员函数非常简单：它们只改变对象的内部状态，有时在事件队列（ event queue）中添加将来要发生的事件，在这种情况下最适合使用委托。但是，每一个委托只被调用（ invoked）一次。一开始，我使用了 boost::function，但我发现程序运行时，给委托所分配的内存空间占用了整个程序空间的三分之一还要多！“我要真正的委托！”我在内心呼喊着，“真正的委托只需要仅仅两行汇编指令啊！”
我并不能总是能够得到我想要的，但后来我很幸运。我在这儿展示的代码（代码下载链接见译者注 ）几乎在所有编译环境中都产生了优化的汇编代码。最重要的是，调用一个含有单个目标的委托（ single-target delegate）的速度几乎同调用一个普通函数一样快 。实现这样的代码并没有用到什么高深的东西，唯一的遗憾就是，为了实现目标，我的代码和标准 C++的规则有些偏离。我使用了一些有关成员函数指针的未公开知识才使它能够这样工作。如果你很细心，而且不在意在少数情况下的一些编译器相关（ compiler-specific）的代码，那么高性能的委托机制在任何 C++编译器下都是可行的。
诀窍：将任何类型的成员函数指针转化为一个标准的形式
我的代码的核心是一个能够将任何类的指针和任何成员函数指针分别转换为一个通用类的指针和一个通用成员函数的指针的 类。由于 C++没有“通用成员函数（ generic member function）”的类型，所以我把所有类型的成员函数都转化为一个在代码中未定义的 CGenericClass类的成员函数。
大多数编译器对所有的成员函数指针平等地对待，不管他们属于哪个类。所以对这些编译器来说，可以使用 reinterpret_cast 将一个特定的成员函数指针转化为一个通用成员函数指针。事实上，假如编译器不可以，那么这个编译器是不符合标准的。对于一些接近标准（ almost-compliant）的编译器，比如 Digital Mars，成员函数指针的 reinterpret_cast转换一般会涉及到一些额外的特殊代码，当进行转化的成员函数的类之间没有任何关联时，编译器会出错。对这些编译器，我们使用一个名为 horrible_cast 的内联函数（在函数中使用了一个 union来避免 C++的类型检查）。使用这种方法看来是不可避免的�� boost::function也用到了这种方法。
对于其他的一些编译器（如 Visual C++, Intel C++和 Borland C++），我们必须将多重（ multiple-）继承和虚拟（ virtual-）继承类的成员函数指针转化为单一（ single-）继承类的函数指针。为了实现这个目的，我巧妙地使用了模板并利用了一个奇妙的戏法。注意，这个戏法的使用是因为这些编译器并不是完全符合标准的，但是使用这个戏法得到了回报：它使这些编译器产生了优化的代码。
既然我们知道编译器是怎样在内部存储成员函数指针的，并且我们知道在问题中应该怎样为成员函数指针调整 this指针，我们的代码在设置委托时可以自己调整 this指针。对单一继承类的函数指针，则不需要进行调整；对多重继承，则只需要一次加法就可完成调整；对虚拟继承 …就有些麻烦了。但是这样做是管用的，并且在大多数情况下，所有的工作都在编译时完成！
这是最后一个诀窍。我们怎样区分不同的继承类型？并没有官方的方法来让我们区分一个类是多重继承的还是其他类型的继承。但是有一种巧妙的方法，你可以查看我在前面给出了一个列表（见中篇）——对 MSVC，每种继承方式产生的成员函数指针的大小是不同的。所以，我们可以基于成员函数指针的大小使用模版！比如对多重继承类型来说，这只是个简单的计算。而在确定 unknown_inheritance（ 16字节）类型的时候，也会采用类似的计算方法。
对于微软和英特尔的编译器中采用不标准 12字节的虚拟继承类型的指针的情况，我引发了一个编译时错误（ compile-time error），因为需要一个特定的运行环境（ workaround）。如果你在 MSVC中使用虚拟继承，要在声明类之前使用 FASTDELEGATEDECLARE宏。而这个类必须使用 unknown_inheritance（未知继承类型）指针（这相当于一个假定的 __unknown_inheritance 关键字）。例如：
FASTDELEGATEDECLARE(CDerivedClass)
class CDerivedClass : virtual public CBaseClass1, virtual public CBaseClass2 {
};
|
这个宏和一些常数的声明是在一个隐藏的命名空间中实现的，这样在其他编译器中使用时也是安全的。 MSVC（ 7.0或更新版本）的另一种方法是在工程中使用 /vmg编译器选项。而 Inter的编译器对 /vmg编译器选项不起作用，所以你必须在虚拟继承类中使用宏。我的这个代码是因为编译器的 bug才可以正确运行，你可以查看代码来了解更多细节。而在遵从标准的编译器中不需要注意这么多，况且在任何情况下都不会妨碍 FASTDELEGATEDECLARE宏的使用。
一旦你将类的对象指针和成员函数指针转化为标准形式，实现单一目标的委托（ single-target delegate）就比较容易了（虽然做起来感觉冗长乏味）。你只要为每一种具有不同参数的函数制作相应的模板类就行了。实现其他类型的委托的代码也大都与此相似，只是对参数稍做修改罢了。
这种用非标准方式转换实现的委托还有一个好处，就是委托对象之间可以用等式比较。目前实现的大多数委托无法做到这一点，这使这些委托不能胜任一些特定的任务，比如实现多播委托（ multi-cast delegates） [Sutter3]。
静态函数作为委托目标（ delegate target）
理论上，一个简单的非成员函数（ non-member function），或者一个静态成员函数（ static member function）可以被作为委托目标（ delegate target）。这可以通过将静态函数转换为一个成员函数来实现。我有两种方法实现这一点，两种方法都是通过使委托指向调用这个静态函数的“调用器（ invoker）”的成员函数 的方法来实现的。
第一种方法使用了一个邪恶的方法（ evil method）。你可以存储函数指针而不是 this指针，这样当调用“调用器”的函数时，它将 this指针转化为一个静态函数指针，并调用这个静态函数。问题是这只是一个戏法，它需要在代码指针和数据指针之间进行转换。在一个系统中代码指针的大小比数据指针大时（比如 DOS下的编译器使用 medium内存模式时），这个方法就不管用了。它在目前我知道的所有 32位和 64位处理器上是管用的。但是因为这种方法还是不太好，所以仍需要改进。
另一种是一个比较安全的方法（ safe method），它是将函数指针作为委托的一个附加成员。委托指向自己的成员函数。当委托被复制的时候，这些自引用（ self-reference）必须被转换，而且使“ =”和“ ==”运算符的操作变得复杂。这使委托的大小增至 4个字节，并增加了代码的复杂性，但这并不影响委托的调用速度。
我已经实现了上述两种方法，两者都有各自的优点：安全的方法保证了运行的可靠性，而邪恶的方法在支持委托的编译器下也可能会产生与此相同的汇编代码。此外，安全的方法可避免我以前讨论的在 MSVC中使用多重继承和虚拟继承时所出现的问题。我在代码中给出的是“安全的方法”的代码，但是在我给出的代码中“邪恶的方法”会通过下面的代码生效：
#define (FASTDELEGATE_USESTATICFUNCTIONHACK)
|
多目标委托（ multiple-target delegate）及其扩展
使用委托的人可能会想使委托调用多个目标函数，这就是多目标委托（ multiple-target delegate） ，也称作多播委托（ multi-cast delegate） 。实现这种委托不会降低单一目标委托（ single-target delegate） 的调用效率，这在现实中是可行的。你只需要为一个委托的第二个目标和后来的更多目标在堆上分配空间就可以了，这意味着需要在委托类中添加一个数据指针，用 来指向由该委托的目标函数组成的单链表的头部节点。如果委托只有一个目标函数，将这个目标像以前介绍的方法一样保存在委托中就行了。如果一个委托有多个目 标函数，那么这些目标都保存在空间动态分配的链表中，如果要调用函数，委托使用一个指针指向一个链表中的目标（成员函数指针）。这样的话，如果委托中只有 一个目标，函数调用存储单元的个数为 1；如果有 n（ n>0）个目标，则函数调用存储单元的个数为 n+1（因为这时函数指针保存在链表中，会多出一个链表头，所以要再加一——译者注），我认为这样做最合理。
由 多播委托引出了一些问题。怎样处理返回值？（是将所有返回值类型捆绑在一起，还是忽略一部分？）如果把同一个目标在一个委托中添加了两次那会发生什么？ （是调用同一个目标两次，还是只调用一次，还是作为一个错误处理？）如果你想在委托中删除一个不在其中的目标应该怎么办？（是不管它，还是抛出一个异 常？）
最重要的问题是在使用委托时会出现无限循环的情况，比如， A委托调用一段代码，而在这段代码中调用 B委托，而在 B委托调用的一段代码中又会调用 A委托。很多事件（ event）和信号跟踪（ signal-slot）系统会有一定的方案来处理这种问题。
为 了结束我的这篇文章，我的多播委托的实现方案就需要大家等待了。这可以借鉴其他实现中的方法——允许非空返回类型，允许类型的隐式转换，并使用更简捷的语 法结构。如果我有足够的兴趣我会把代码写出来。如果能把我实现的委托和目前流行的某一个事件处理系统结合起来那会是最好不过的事情了（有自愿者吗？）。
本文代码的使用
原代码包括了 FastDelegate的实现（ FastDelegate.h）和一个 demo .cpp的文件用来展示使用 FastDelegate的语法。对于使用 MSVC的读者，你可以建立一个空的控制台应用程序 (Console Application)的工程，再把这两个文件添加进去就好了，对于 GNU的使用者，在命令行输入“ gcc demo.cpp”就可以了。
FastDelegate可以在任何参数组合下运行，我建议你在尽可能多的编译器下尝试，你在声明委托的时候必须指明参数的个数。在这个程序中最多可以使用 8个参数，若想进行扩充也是很容易的。代码使用了 fastdelegate命名空间，在 fastdelegate命名空间中有一个名为 detail的内部命名空间。
Fastdelegate使用构造函数或 bind()可以绑定一个成员函数或一个静态（全局）函数，在默认情况下，绑定的值为 0（空函数）。可以使用“！”操作符判定它是一个空值。
不像用其他方法实现的委托，这个委托支持等式运算符（ ==, !=）。
下面是 FastDelegateDemo.cpp的节选，它展示了大多数允许的操作。 CBaseClass是 CDerivedClass的虚基类。你可以根据这个代码写出更精彩的代码，下面的代码只是说明使用 FastDelegate的语法：
using namespace fastdelegate;
int main(void)
{
printf("-- FastDelegate demo --\nA no-parameter
delegate is declared using FastDelegate0\n\n");
FastDelegate0 noparameterdelegate(&SimpleVoidFunction);
noparameterdelegate();
printf("\n-- Examples using two-parameter delegates (int, char *) --\n\n");
typedef FastDelegate2 MyDelegate;
MyDelegate funclist[12];
CBaseClass a("Base A");
CBaseClass b("Base B");
CDerivedClass d;
CDerivedClass c;
funclist[0].bind(&a, &CBaseClass::SimpleMemberFunction);
funclist[1].bind(&SimpleStaticFunction);
funclist[2].bind(&CBaseClass::StaticMemberFunction);
funclist[3].bind(&a, &CBaseClass::ConstMemberFunction);
funclist[4].bind(&b, &CBaseClass::SimpleVirtualFunction);
funclist[5] = MyDelegate(&CBaseClass::StaticMemberFunction);
funclist[6].bind(&d, &CBaseClass::SimpleVirtualFunction);
funclist[7].bind(&c, &CDerivedClass::SimpleDerivedFunction);
funclist[8].bind(&c, &COtherClass::TrickyVirtualFunction);
funclist[9] = MakeDelegate(&c, &CDerivedClass::SimpleDerivedFunction);
MyDelegate dg(&b, &CBaseClass::SimpleVirtualFunction);
char *msg = "Looking for equal delegate";
for (int i=0; i<12; i++) {
printf("%d :", i);
if (funclist[i]==dg) { msg = "Found equal delegate"; };
if (!funclist[i]) {
printf("Delegate is empty\n");
} else {
funclist[i](i, msg);
};
}
};
|
因为我的代码利用了 C++标准中没有定义的行为，所以我很小心地在很多编译器中做了测试。具有讽刺意味的是，它比许多所谓标准的代码更具有可移植性，因为几乎所有的编译器都不是完全符合标准的。目前，核心代码已成功通过了下列编译器的测试：
- Microsoft Visual C++ 6.0, 7.0 (.NET) and 7.1 (.NET 2003) (including /clr ‘managed C++’),
- GNU G++ 3.2 (MingW binaries),
- Borland C++ Builder 5.5.1,
- Digital Mars C++ 8.38 (x86, both 32-bit and 16-bit),
- Intel C++ for Windows 8.0,
- Metroworks CodeWarrior for Windows 9.1 (in both C++ and EC++ modes)
对于 Comeau C++ 4.3 (x86, SPARC, Alpha, Macintosh)，能够成功通过编译，但不能链接和运行。对于 Intel C++ 8.0 for Itanium能够成功通过编译和链接，但不能运行。
此外，我已对代码在 MSVC 1.5 和 4.0， Open Watcom WCL 1.2上的运行情况进行了测试，由于这些编译器不支持成员函数模版，所以对这些编译器，代码不能编译成功。对于嵌入式系统不支持模版的限制，需要对代码进行大范围的修改。（这一段是在刚刚更新的原文中添加的——译者注）
而最终的 FastDelegate并没有进行全面地测试，一个原因是，我有一些使用的编译器的评估版过期了，另一个原因是——我的女儿出生了！如果有足够的兴趣，我会让代码在更多编译器中通过测试。 (这一段在刚刚更新的原文中被删去了，因为作者目前几乎完成了全部测试。——译者注 )
总结
为了解释一小段代码，我就得为这个语言中具有争议的一部分写这么一篇长长的指南。为了两行汇编代码，就要做如此麻烦的工作。唉 ~！
我希望我已经澄清了有关成员函数指针和委托的误解。我们可以看到为了实现成员函数指针，各种编译器有着千差万别的方法。我们还可以看到，与流行的观点不同，委托并不复杂，并不是高层结构，事实上它很简单。我希望它能够成为这个语言（标准 C++）中的一部分，而且我们有理由相信目前已被一些编译器支持的委托，在不久的将来会加入到标准 C++的新的版本中（去游说标准委员会！）。
据我所知，以前实现的委托都没有像我在这里为大家展示的 FastDelegate一样有如此高的性能。我希望我的代码能对你有帮助。如果我有足够的兴趣，我会对代码进行扩展，从而支持多播委托（ multi-cast delegate）以及更多类型的委托。我在 CodeProject上学到了很多，并且这是我第一次为之做出的贡献。
参考文献
[GoF] “Design Patterns: Elements of Reusable Object-Oriented Software”, E. Gamma, R. Helm, R. Johnson, and J. Vlissides.
I’ve looked at dozens of websites while researching this article. Here are a few of the most interesting ones:
我在写这篇文章时查看了很多站点，下面只是最有趣的一些站点：
[Boost] Delegates can be implemented with a combination of boost::function and boost::bind. Boost::signals is one of the most sophisticated event/messaging system available. Most of the boost libraries require a highly standards-conforming compiler. （ http://www.boost.org/）
[Loki] Loki provides ‘functors’ which are delegates with bindable parameters. They are very similar to boost::function. It’s likely that Loki will eventually merge with boost. （ http://sourceforge.net/projects/loki-lib）
[Qt] The Qt library includes a Signal/Slot mechanism (i.e., delegates). For this to work, you have to run a special preprocessor on your code before compiling. Performance is very poor, but it works on compilers with very poor template support. （ http://doc.trolltech.com/3.0/signalsandslots.html）
[Libsigc++] An event system based on Qt’s. It avoids the Qt’s special preprocessor, but requires that every target be derived from a base object class (using virtual inheritance – yuck!). （ http://libsigc.sourceforge.net/）
[Hickey]. An old (1994) delegate implementation that avoids memory allocations. Assumes that all pointer-to-member functions are the same size, so it doesn’t work on MSVC. There’s a helpful discussion of the code here. （ http://www.tutok.sk/fastgl/callback.html）
[Haendal]. A website dedicated to function pointers?! Not much detail about member function pointers though. （ http://www.function-pointer.org/）
[Sutter1] Generalized function pointers: a discussion of how boost::function has been accepted into the new C++ standard. （ http://www.cuj.com/documents/s=8464/cujcexp0308sutter/）
[Sutter2] Generalizing the Observer pattern (essentially, multicast delegates) using std::tr1::function. Discusses the limitations of the failure of boost::function to provide operator ==.
（ http://www.cuj.com/documents/s=8840/cujexp0309sutter）
[Sutter3] Herb Sutter’s Guru of the Week article on generic callbacks. （ http://www.gotw.ca/gotw/083.htm）
关于作者 Don Clugston
我在澳大利亚的 high-tech startup工作，是一个物理学家兼软件工程师。目前从事将太阳航空舱的硅质晶体玻璃（ CSG）薄膜向市场推广的工作。我从事有关太阳的（ solar）研究，平时喜欢做一些软件（用作数学模型、设备控制、离散事件触发器和图象处理等），我最近喜欢使用 STL和 WTL写代码。我非常怀念过去的光荣岁月：）而最重要的，我有一个非常可爱的儿子（ 2002年 5月出生）和一个非常年轻的小姐（ 2004年 5月出生）。
“黑暗不会战胜阳光，阳光终究会照亮黑暗。”
译者注
由于本文刚发表不久，作者随时都有可能对文章或代码进行更新，若要浏览作者对本文的最新内容，请访问：
http://www.codeproject.com/cpp/FastDelegate.asp
点击以下链接下载 FastDelegate的源代码：
http://www.codeproject.com/cpp/FastDelegate/FastDelegate_src.zip