成员函数指针与高性能的C++委托（上篇）

现在你可能会觉得成员函数指针是有些奇异。但它可以用来做什么呢？对此我在网上做了非常广泛的调查。最后我总结出使用成员函数指针的两点原因：

在写这篇文章中，我有一点需要指明：“允许成员函数指针之间进行转换（，把这个规则纳入

为了让你确信这一具有争议的论断，考虑一下在一个文件中只有下面的一段代码，这段代码是合法的：

MFC利用了一个可怕的编译器漏洞（hack），它将所有可能出现的成员函数指针放到一个庞大的联合（union）中，从而避免了通常需要进行的C++类型匹配检查。afximpl.h和cmdtarg.cpp中名为MessageMapFunctions的union，你就会发现这一恐怖的事实。）因为MFC有如此重要的一部分代码，所以事实是，所有的编译器都为这个漏洞开了绿灯。（但是，在后面我们会看到，如果一些类用到了多重继承，这个漏洞在）MSVC中就不会起作用，这正是在使用MFC时只能必须使用单一继承的原因。boost::function中有类似的漏洞（但不是太严重）。看起来如果你想做任何有关成员函数指针的比较有趣的事，你就必须做好与这个语言的漏洞进行挑战的准备。要是你想否定C++的成员函数指针设计有缺陷的观点，看来是很难的。cast），而不允许在转换完成后调用其中的函数”C++的标准中是可笑的。首先，很多流行的编译器对这种转换不支持（所以，转换是标准要求的，但不是可移植的）。其次，所有的编译器，如果转换成功，调用转换后的成员函数指针时仍然可以实现你预期的功能：那编译器就没有所谓的“undefined behavior（未定义的行为）”这类错误出现的必要了（调用（Invocation）是可行的，但这不是标准！）。第三，允许转换而不允许调用是完全没有用处的，只有转换和调用都可行，才能方便而有效地实现委托，从而使这种语言受益。

class SomeClass;

typedef void (SomeClass::* SomeClassFunction)(void);

void Invoke(SomeClass *pClass, SomeClassFunction funcptr) {

(pClass->*funcptr)(); };

注意到编译器必须生成汇编代码来调用成员函数指针，其实编译器对

为解释我的断言的另一半——转换并不能按照标准所说的方式进行，我需要在细节上讨论编译器是怎样实现成员函数指针的。我同时会解释为什么使用成员函数指针的规则具有如此严格的限制。获得详细论述成员函数指针的文档不是太容易，并且大家对错误的言论已经习以为常了，所以，我仔细检查了一系列编译器生成的汇编代码……

（待续）

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=33068

[ 收藏到我的网摘] [ 发送Trackback] 周翔发表于 2004年07月03日 14:49:00

特别推荐：

想在这里投放广告？点击查看详情

嵌入式项目实训，找港湾教育！
根据薪资报告，具有10年工作经验的高级嵌入式工程师年薪在30万元，初级的嵌入式软件开发人员5000元 c
非常4＋1大学生实训计划，首付6800
4个月的全套Java技术体系的实训, 1个月的企业大型真实项目的实战开发。 c
阿里巴巴急聘JAVA EE架构师
阿里巴巴是一家由中国人创办的国际化的互联网公司，高薪邀请英才 :) c
主机完全DIY,域名免费试用
时代互联100M主机 216元/年 c
大规模并行运算的利器——CUDA
CUDA是当今世界上唯一针对GPU的C环境 CUDA——走向GPGPU新时代，走进GPU通用计 c

上一篇: 成员函数指针与高性能的C++委托（中篇） | 下一篇: 哲学家就餐问题的C#实现

# 一己薄剑发表于2006-04-21 16:30:00 IP: 211.100.21.*

TrackBack来自《如何动态保存不同类的对象的成员函数的地址？--解决》：

即C 中委托的实现

# step_by_step 发表于2004-07-05 12:32:00 IP: 218.95.232.*

不错，详细

# freesmile 发表于2004-07-05 20:43:00 IP: 202.109.79.*

原文应该是
"For case (a), static_cast<Base1mfp>(x) will work, but static_cast<Base2mfp>(x) will fail."

# bullHEcow 发表于2004-07-05 16:43:00 IP: 222.95.25.*

“&DerivedClass::some_member_func是一个SomeClass类的成员函数指针”这个是指针，还是函数的地址

# bullHEcow 发表于2004-07-05 16:52:00 IP: 222.95.25.*

对于情况(a)，static_cast(x)是合法的，而static_cast(x)则是错误的。
上面这两个static_cast(x) 有区别吗？

# bullHEcow 发表于2004-07-06 08:35:00 IP: 222.95.26.*

“&DerivedClass::some_member_func是一个SomeClass类的成员函数指针”这个是指针，还是函数的地址

# fellow 发表于2004-07-06 08:39:00 IP: 218.13.32.*

有点晕,扶扶我~~

# hifrog 发表于2004-07-06 08:48:00 IP: 61.162.67.*

应该是：
"对于情况(a)，static_cast<Base1mfp>(x)是合法的，而static_cast<Base2mfp>(x)则是错误的。"——因为只能转化为子类的第一个父类。

排版时漏掉了，多谢兄弟提醒。

# abc 发表于2004-07-06 09:37:00 IP: 218.186.122.*

this is very very out dated.

1. pointer to class function will follow virtual keyword. ie, pointer to a virtual function in base class when called using a derived class, the function in drived class will be called.
2. member function pointer has different size as normal pointer. it contains infomation to deal with virtual functions and MI. it's senseless to to cast it to a different type or with a differnet(ie, no inheritance) class. the result IS UNDEFINED.
3. functor + arguent/caller bind will work the same way as closuer.

# aimar 发表于2004-07-06 10:36:00 IP: 61.145.247.*

谁说成员函数指针只是用来做教学的，在泛型编程中，函数指针和成员函数指针数组是经常用到的，另外，成员函数指针数组在多重继承的时候还有一个大陷阱，如果派生类定义了函数指针数组，而它的基类有虚函数，那么初始化的时候...

# 周星星发表于2004-07-07 13:41:00 IP: 221.2.225.*

我不想给你泼冷水，但你这篇文章中全是似是而非的错误，我也懒得说，毕竟打字令人烦恼。

# aweay 发表于2004-07-08 09:57:00 IP: 218.21.42.*

这篇文章我也翻译过，原文本来就很麻烦，支持一下楼主

# my name 发表于2004-07-08 10:44:00 IP: 61.175.228.*

函数名本来就是指针，函数指针就是指向指针的指针，也就是双重指针，这句话“如果你的函数指针指向一个型如float some_func(int, char *)的函数，这样做就可以了：

my_func_ptr = some_func;

当你想调用它所指向的函数时，你可以这样写：

(*my_func_ptr)(7, "Arbitrary String");”
这样不是*my_func_ptr=some_func了吗？可是上面是
my_func_ptr=some_func呀？这样可以调用吗？

# yuk 发表于2004-07-09 20:20:00 IP: 61.129.192.*

见鬼去真他妈天书

# arrowwolfer 发表于2004-07-09 20:34:00 IP: 61.155.233.*

my_func_ptr = some_func;

当你想调用它所指向的函数时，你可以这样写：

(*my_func_ptr)(7, "Arbitrary String");”
这样不是*my_func_ptr=some_func了吗？可是上面是
my_func_ptr=some_func呀？这样可以调用吗？

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

本来
(*my_func_ptr)(7, "Arbitrary String");
也可以写成这样：
my_func_ptr(7, "Arbitrary String");

# bullHEcow 发表于2004-07-09 13:26:00 IP: 222.95.24.*

to：楼上
“函数名本来就是指针”我觉的这句话不对

# stevenxu 发表于2004-07-09 14:51:00 IP: 219.82.170.*

这篇文章好像是个平时主要用Java或者别的什么语言的人写的。

# ChenA 发表于2004-07-09 17:23:00 IP: 220.248.6.*

我不想给你泼冷水，但你这篇文章中全是似是而非的错误，我也懒得说，毕竟打字令人烦恼。

那你就什么也别说，最烦你这种人。

# donkey0811 发表于2004-07-11 11:12:00 IP: 219.145.162.*

真的是很难懂诶

# studyself 发表于2004-07-13 13:44:00 IP: 202.114.3.*

好贴！

# tiger 发表于2004-07-13 16:55:00 IP: 221.232.181.*

说的对

# 111 发表于2004-07-13 11:09:00 IP: 221.6.17.*

不要用什么面向对象的东西来吓唬人，C++ 是面向效率的，C++中的函数指针要比代理之类的东西灵活得多，也高效的多。

# hifrog 发表于2004-07-13 21:08:00 IP: 61.162.66.*

因为复习考研，好久没上网了，今天到自己的Blog来看到有很多兄弟来给我加油，我很是感激。我想在这里简要说一说作者的观点：
1.成员函数指针本身是个好东西。问题出在成员函数所在类的继承属性上，如果这个类是多重继承类或虚拟继承类，在使用成员函数指针时会出现问题。而C++的标准也没有对这个问题进行明确的回答。
2.委托是一个更好的东西。委托的效率在“实质上”比成员函数指针高的多，但在“实际上”委托的被“一些设计者”变成了高层次的、庞大的、缓慢的东西。

如果各位朋友真的要读这篇文章，我想最好能把这篇文章从头到尾读完。

# jeff 发表于2004-07-14 16:34:00 IP: 218.19.114.*

其实用模板就可以实现“委托”。这是我在写事件处理器时用的一个模板类

template<class HandlerClass>
class CEventHandler
{
public:
typedef CEventHandler<HandlerClass> EVENTHANDLER;
typedef void (HandlerClass::*LPHANDLEFUNC)(const CEventItem& refEvt);

DWORD m_dwEvtID;
LPHANDLEFUNC m_lpHandleFunction;

CEventHandler(const EVENTHANDLER& refEvtHandler)
{
m_dwEvtID=refEvtHandler.dwEvtID;
m_lpHandleFunction=refEvtHandler.lpHandleFunc;
};

const EVENTHANDLER& operator = (const EVENTHANDLER& refEvtHandler)
{
if(&refEvtHandler!=this)
{
m_dwEvtID=refEvtHandler.dwEvtID;
m_lpHandleFunction=refEvtHandler.lpHandleFunc;
}

return *this;
};

CEventHandler(DWORD dwEvtID,LPHANDLEFUNC lpHandleFunc)
{
m_dwEvtID=dwEvtID;
m_lpHandleFunction=lpHandleFunc;
};

CEventHandler()
{
m_dwEvtID=-1;
m_lpHandleFunction=NULL;
};

virtual ~CEventHandler()
{
m_dwEvtID=-1;
m_lpHandleFunction=NULL;
};
};

# jeff 发表于2004-07-14 16:41:00 IP: 218.19.114.*

贴错代码了。下面这个才对^_^
template<class HandlerClass>
class CPacketHandlerT : public CPacketHandler
{
typedef void (HandlerClass::*LPHANDLEFUNC)(const CCMPPPacket* lpPacket);

private:
HandlerClass& m_refHandlerClassInstance;
LPHANDLEFUNC m_lpHandleFunction;

public:

virtual void Handle(const CCMPPPacket* lpPacket)
{
ASSERT(m_lpHandleFunction);

if(m_lpHandleFunction)
(m_refHandlerClassInstance.*m_lpHandleFunction)(lpPacket);
}

CPacketHandlerT(HandlerClass& refClassInstance,LPHANDLEFUNC lpHandleFunc)
:m_refHandlerClassInstance(refClassInstance),m_lpHandleFunction(lpHandleFunc)
{
ASSERT(lpHandleFunc);
};

CPacketHandlerT(HandlerClass* pClassInstance,LPHANDLEFUNC lpHandleFunc)
:m_refHandlerClassInstance(*pClassInstance),m_lpHandleFunction(lpHandleFunc)
{
ASSERT(lpHandleFunc);
};

virtual ~CPacketHandlerT()
{
m_lpHandleFunction=NULL;
};

};

# zihan 发表于2004-07-16 22:00:00 IP: 61.235.65.*

楼上贴的代码其实和楼主的差不多，只是通过摸板更加通用，当然比楼主要好一点。

这是一篇不错的文章，可是我见过很多人在csdn上面发贴，都受到一些人的乱骂，不知道他们是真的很厉害，还是要显示自己水平很高，也许对你来说很简单，甚至是错误的，可是毕竟对作者来说是一片好意，我觉得我们在提意见的时候应该注意方式。

# studyself 发表于2004-07-17 14:16:00 IP: 202.114.30.*

好贴！

# a b c 发表于2004-07-19 19:33:00 IP: 61.149.68.*

虽然我还看不大懂楼主的文章，但是，我还是受益非浅。

# ANGUS 发表于2004-07-18 15:53:00 IP: 202.213.113.*

(*my_func_ptr)(7, "Arbitrary String");
也可以写成这样：
my_func_ptr(7, "Arbitrary String");
两种方法都可以。

# guolb 发表于2004-07-20 13:49:00 IP: 61.51.131.*

函数名就是函数的起始地址，
函数指针也是函数的起始地址，并不是指向指针的指针。

数组变量和数组指针应该和这个相似的把。

# 星哥发表于2004-09-27 17:53:00 IP: 165.170.128.*

我现在看到那个叫周星星的人留言我就觉得有点悲哀，他自己也不嫌寒碜，要不然你就匿名，要不然就说出点道理，不要看谁都不顺眼，我敢打赌让那个星星牛人他翻不出楼主这么好的文章，做人要厚道，不要随便给比人泼冷水。

# coordinate 发表于2005-06-16 14:28:00 IP: 61.186.252.*

"对于情况(a)，static_cast<Base1mfp>(x) ... MSVC会发出C4407号警告，而Digital Mars C++会出现编译错误。"
我用VC6做了如下试验，为什么没有任何的警告和错误？
#include "stdafx.h"
#include <iostream.h>
class Base1
{
public:
void b1_test(void);
};
void Base1::b1_test()
{
cout<<"Base1"<<endl;
}
class Base2
{
public:
void b2_test(void);
};
void Base2::b2_test()
{
cout<<"Base2"<<endl;
}

class Derived1:public Base1,public Base2
{
public:
void b1_test(void);
void d1_test(void);
};

void Derived1::b1_test()
{
cout<<"Derived test"<<endl;
}

void Derived1::d1_test()
{
cout<<"d1_test"<<endl;
}
class Derived2:public Base2,public Base1
{
public:
void b2_test(void);
};

void Derived2::b2_test()
{
cout<<"Derived2 test2"<<endl;
}
typedef void (Base1::*base1_func)();
typedef void (Base2::*base2_func)();
typedef void (Derived1::*derived1_func)();
typedef void (Derived2::*derived2_func)();
void fun(Base1 *b)
{
b->b1_test();
}
int main(int argc, char* argv[])
{
derived1_func x;
static_cast<base1_func>(x);
static_cast<base2_func>(x);
return 0;
}

SomeClass类一无所知。显然，除非链接器进行了一些极端精细的优化措施，否则代码会忽视类的实际定义而能够正确地运行。而这造成的直接后果是，你可以“安全地”调用从完全不同的其他类中转换过来的成员函数指针。

成员函数指针与高性能的C++委托（上篇）

评论

你可能感兴趣的:(C++,function,Class,mfc,编译器,Pointers)