扫二维码与项目经理沟通
我们在微信上24小时期待你的声音
解答本文疑问/技术咨询/运营咨询/技术建议/互联网交流
本篇文章给大家分享的是有关c++成员函数指针是什么,小编觉得挺实用的,因此分享给大家学习,希望大家阅读完这篇文章后可以有所收获,话不多说,跟着小编一起来看看吧。
创新互联专注于谷城企业网站建设,响应式网站,商城网站制作。谷城网站建设公司,为谷城等地区提供建站服务。全流程按需求定制制作,专业设计,全程项目跟踪,创新互联专业和态度为您提供的服务
C++语言支持指向成员函数的指针这一语言机制。就像许多其它C++语言机制一样,它也是一把双刃剑,用得好,能够提高程序的灵活性、可扩展性等等,但是也存在一些不易发现的陷阱,我们在使用它的时候需要格外注意,尤其是在我们把它和c++其它的语言机制合起来使用的时候更是要倍加当心。
关键字:成员函数指针,继承,虚函数,this指针调整,static_cast
C++成员函数指针(pointer
to member function)的用法和C语言的函数指针有些相似.
下面的代码说明了成员函数指针的一般用法:
class ClassName {public: int foo(int); }
int (ClassName::*pmf)(int)
ClassName c; //.*的用法,经由对象调用 (c.*pmf)(5); // A
ClassName *pc = &c; //->*的用法,经由对象指针调用 (Pc->*pmf)(6); // B
|
使用typedef可以让代码变得略微好看一点:
typedef int (ClassName::*PMF)(int); PMF pmf = &ClassName::foo; |
注意获取一个成员函数指针的语法要求很严格:
1)
不能使用括号:例如&(ClassName::foo)不对。
2)
必须有限定符:例如&foo不对。即使在类ClassName的作用域内也不行。
3)
必须使用取地址符号:例如直接写ClassName::foo不行。(虽然普通函数指针可以这样)
所以,必须要这样写:&ClassName::foo。
C++成员函数的调用需要至少3个要素:this指针,函数参数(也许为空),函数地址。上面的调用中,->*和.*运算符之前的对象/指针提供了this(和真正使用this并不完全一致,后面会讨论),参数在括号内提供,pmf则提供了函数地址。
注意这里成员函数指针已经开始显示它“异类”的天性了。上面代码中注释A和B处两个表达式,产生了一个在C++里面没有类型(type)的“东西”(这是C++语言里面唯一的例外,其它任何东西都是有类型的),这就是.*和->*运算符:
(c.*pmf)
(Pc->*pmf)
这两个运算符求值生成的“东西”我们只知道可以把它拿来当函数调用一样使唤,别的什么也不能干,甚至都不能把它存在某个地方。就因为这个原因,Andrei Alexandrescu在他那本著名的《Modern c++ design》里面就说,成员函数指针和这两个操作符号是“curiously half-baked concept in c++”。(5.9节)
C++里面引入了“引用”(reference)的概念,可是却不存在“成员函数的引用”,这也是一个特殊的地方。(当然,我们可以使用“成员函数指针”的引用,呵呵)
C++是一种Multi-Paradigm的语言,各种语言机制混合使用也是平常的事。这里我们只提几种会影响到成员函数指针实现和运行的语言机制。
根据C++语言规定,成员函数指针具有contravariance特性,就是说,基类的成员函数指针可以赋值给继承类的成员函数指针,C++语言提供了默认的转换方式,但是反过来不行。
首先要说明,指向虚拟成员函数(virtual function
member)的指针也能正确表现出虚拟函数的特性。举例说明如下:
class B { public:
virtual int
foo(int) {/* B's
implementation */return 0; } };
class D : public
B { public: virtual
int foo(int) { /* D's implementation */ return
0; } };
int
(B::*pmf)(int) = &B::foo;
D d;
B* pb = &d;
(d.*pmf)(0); //这里执行D::foo
(pb->*pmf)(0); //这里执行D::foo,多态
C++借由虚函数提供了运行时多态特性,虚函数的实现和普通函数有很大的不同。一般编译器都是采用大家都熟悉的v-table (virtual function table)的方式。所有的虚函数地址存在一个函数表里面,类对象中存储该函数表的首地址(vptr_point)。运行时根据this指针、虚函数索引和虚函数表指针找到函数调用地址。
3.2多继承因为这些不同,所以成员函数指针碰上虚函数的时候,也需要作特殊的处理,才能正确表现出所期望的虚拟性质。
这里扯上多继承,是因为多继承的存在导致了成员函数指针的实现的复杂性。这是因为编译器有时候需要进行”this”指针调整。
举例说明如下:
class B1{};
class B2{};
class D: public
B1, public B2{}
假设上面三个对象都不涉及到虚函数,D在内存中的典型布局如下图所示(如果有虚函数则多一个vptr指针, 差别不大)。
现在假设我们经由D对象调用B2的函数,
D d;
d.fun_of_b2();
这里传给fun_of_b2的this指针不能是&d,而应该对&d加上一个偏移,得到D内含的B2子对象的首地址处。
成员函数指针的实现必须考虑这种情况。
多继承总是不那么受欢迎。不过即使是单继承,上面的情况也会出现。考虑下面的例子:
class B{}; //non-virtual
class
class D :public B{}; //virtual class
假设B是一个普通的类,没有虚拟成员函数。而D加上了虚拟成员函数。
因为D引入了vptr指针,而一般的实现都将vptr放在对象的开头,这就导致经由D对象访问B的成员函数的时候,仍然需要进行this指针的调整。
D d;
d.fun_of_b(); //this指针也需要调整,否则fun_of_b的行为就会异常
从上面一节我们可以看到,编译器要实现成员函数指针,有几个问题是绕不过去的:
1) 函数是不是虚拟函数,这个涉及到虚函数表(__vtbl)的访问。
2) 函数运行时,需不需要调整this指针,如何调整。这个涉及到C++对象的内存布局。
事实上,成员函数指针必须记住这两个信息。为什么要记住是否为虚函数就不用解释了。但是this指针调整为什么要记住呢?因为在.*和->*运算符求值时必须用到。 考虑上面那个多继承的例子:
int (D::*pmf)(int) = &B2::foo_of_b2; //A
D d;
(d.*pmf)(0);
//B
看看上面的代码,其实我们在A处知道需要进行this指针调整,也知道该怎么调整。但是这时候this还没出世呢,还不到调整的时候。到了B处终于有了This指针了,可是又不知道该怎样调整了。所以pmf必须记住调整方式,到了B处调用的时候,再来进行调整。
Microsoft VC的实现采用的是Microsoft一贯使用的Thunk技术(不知道这个名字怎么来的,不过有趣的是把它反过来拼写就变成了大牛Knuth的名字,呵呵)。
对于Mircosoft来说,成员函数指针实际上分两种,一种需要调节this指针,一种不需要调节this指针。
先分清楚那些情况下成员函数指针需要调整this指针,那些情况下不需要。回忆上一节讨论的c++对象内存布局的说明,我们可以得出结论如下:
如果一个类对象obj含有一些子对象subobj,这些子对象的首地址&subobj和对象自己的首地址&obj不等的话,就有可能需要调整this指针。因为我们有可能把subobj的函数当成obj自己的函数来使用。
根据这个原则,可以知道下列情况不需要调整this指针:
1)
继承树最顶层的类。
2)
单继承,若所有类都不含有虚拟函数,那么该继承树上所有类都不需要调整this指针。
3)
单继承,若最顶层的类含有虚函数,那么该继承树上所有类都不需要调整this指针。
下列情况可能进行this指针调整:
1)
多继承
2)
单继承,最顶的base class不含virtual function,但继承类含虚函数。那么这些继承类可能需要进行this指针调整。
Microsoft把这两种情况分得很清楚。所以成员函数的内部表示大致分下面两种:
struct void* vcall_addr; };
|
struct void* vcall_addr; int }; |
这两种表示导致成员函数指针的大小可能不一样,pmf_type1大小为4,pmf_type2大小为8。有兴趣的话可以写一段代码测试一下。
上面两个结构中出现了vcall_addr,它就是Microsoft的Thunk技术核心所在。简单的说,vcall_addr是一个指针,这个指针隐藏了它所指的函数是虚拟函数还是普通函数的区别。事实上,若它所指的成员函数是一个普通成员函数,那么这个地址也就是这个成员函数的函数地址。若是虚拟成员函数,那么这个指针指向一小段代码,这段代码会根据this指针和虚函数索引值寻找出真正的函数地址,然后跳转(注意是跳转jmp,而不是函数调用call)到真实的函数地址处执行。
看一个例子。
//源代码 class C { public: int virtual virtual };
void foo(C *c) { int
pmf = &C::nv_fun1; (c->*pmf)(0x12345678);
pmf = &C::v_fun; (c->*pmf)(0x87654321);
pmf = &C::v_fun_2; (c->*pmf)(0x87654321); }
|
; foo的汇编代码,release版本,部分地方进行了优化 :00401000 56 push esi :00401001 8B742408 mov esi, dword ptr [esp+08] ; pmf = &C::nv_fun1; ; (c->*pmf)(0x12345678); :00401005 6878563412 push 12345678 : : ; pmf = &C::v_fun; ; (c->*pmf)(0x87654321); :00401011 6821436587 push 87654321 :00401016 8BCE mov ecx, esi ;this :00401018 E803070000 call 00401720 ; pmf = &C::v_fun_2; ; (c->*pmf)(0x87654321); :0040101D 6821436587 push 87654321 :00401022 8BCE mov ecx, esi ;this :00401024 E807070000 call 00401730 :00401029 5E pop esi : |
:00401030 : |
:00401720 :00401722 FF20 jmp dword ptr [eax] |
:00401730 :00401732 FF6004 jmp [eax+04] |
从上面的汇编代码可以看出vcall_addr的用法。00401030,00401720, 00401730都是vcall_addr的值,其实也就是pmf的值。在调用的地方,我们不能分别出是不是虚函数,所看到的都是一个函数地址。但是在vcall_addr被当成函数地址调用后,进入vcall_addr,就有区别了。00401720,
00401730是两个虚函数的vcall,他们都是先根据this指针,计算出函数地址,然后jmp到真正的函数地址。00401030是C::nv_fun1的真实地址。
Microsoft的这种实现需要对一个类的每个用到了的虚函数,都分别产生这样的一段代码。这就像一个template函数:
template
void
vcall(void* this)
{
jmp this->vptr[index];
//pseudo asm code
}
每种不同的index都要产生一个实例。
Microsoft就是采用这样的方式实现了虚成员函数指针的调用。
不过还有一个this调整的问题,我们还没有解决。上面的例子为了简化,我们故意避开了this指针调整。不过有了上面的基础,我们再讨论this指针调整就容易了。
首先我们需要构造一个需要进行this指针调整的情况。回忆这节开头,我们讨论了哪些情况下需要进行this指针调整。我们用一个单继承的例子来进行说明。这次我们避开virtual/non-virtual function的问题暂不考虑。
class B { public: B():m_b(0x13572468){} int std::cout<<'B'< return } private: int }; class D : public B { public: D():m_d(0x24681357){} virtual std::cout<<'D'< return } private: int }; | // 注意这个例子中virtual的使用 |
void test_this_adjust(D *pd, int { (pd->*pmf)(0x12345678); }
| :00401000 mov eax, dword ptr [esp+04] ; this入参 :00401004 mov ecx, dword ptr [esp+ :00401008 push 12345678 ;参数入栈 :0040100D add ecx, eax : :00401013 ret |
void test_main(D *pd) { test_this_adjust(pd, test_this_adjust(pd, }
| ; test_this_adjust(pd, &D::foo); :00401020 xor ecx, ecx :00401022 push esi :00401023 mov esi, dword ptr [esp+08] ; pd, this指针 :00401027 mov eax, : :0040102D push eax ; push vcall_addr :0040102E push esi :
; test_this_adjust(pd, :00401034 mov ecx, 00000004 ;和上面的调用不同了 :00401039 mov eax, 00401050 ; :0040103E push ecx ; push : :00401040 push esi ; push :00401041 call 00401000 ;
:00401046 add esp, 00000018 :00401049 pop esi : |
注意这里和上面一个例子的区别:
在调用test_this_adjust(pd,
&D::foo)的时候,实际上传入了3个参数,调用相当于
test_this_adjust(pd, vcall_address_of_foo, delta(=0));
调用test_this_adjust(pd,
&B::b_fun)的时候,也是3个参数
test_this_adjust(pd, vcall_address_of_b_fun, delta(=4));
两个调用有个明显的不同,就是delta的值。这个delta,为我们后来调整this指针提供了帮助。
再看看test_this_adjust函数的汇编代码,和上一个例子的不同,也就是多了一句代码:
:0040100D add ecx, eax ; this
= ecx= this+delta
这就是对this指针作必要的调整。
Microsoft根据情况选用下面的结构表示成员函数指针,使用Thunk技术(vcall_addr)实现虚拟函数/非虚拟函数的自适应,在必要的时候进行this指针调整(使用delta)。
struct pmf_type1{ void* };
|
struct pmf_type2{ void* int delta; }; |
GCC对于成员函数指针的实现和Microsoft的方式有很大的不同。
GCC对于成员函数指针统一使用类似下面的结构进行表示:
struct { void* __pfn; long __delta; // offset, 用来进行this指针调整 }; |
先来看看GCC是如何区分普通成员函数和虚拟成员函数的。
不管是普通成员函数,还是虚拟成员函数,信息都记录在__pfn里面。这里有个小小的技巧。我们知道一般来说因为对齐的关系,函数地址都至少是4字节对齐的。这就意味这一个函数的地址,最低位两个bit总是0。(就算没有这个对齐限制,编译器也可以这样实现。) GCC充分利用了这两个bit。如果是普通的函数,__pfn记录该函数的真实地址,最低位两个bit就是全0,如果是虚拟成员函数,最后两个bit不是0,剩下的30bit就是虚拟成员函数在函数表中的索引值。
使用的时候,GCC先取出最低位两个bit看看是不是0,若是0就拿这个地址直接进行函数调用。若不是0,就取出前面30位包含的虚拟函数索引,通过计算得到真正的函数地址,再进行函数调用。
GCC和Microsoft对这个问题最大的不同就是GCC总是动态计算出函数地址,而且每次调用都要判断是否为虚拟函数,开销自然要比Microsoft的实现要大一些。这也差不多可以算成一种时间换空间的做法。
在this指针调整方面,GCC和Mircrosoft的做法是一样的。不过GCC在任何情况下都会带上__delta这个变量,如果不需要调整,__delta=0。
这样GCC的实现比起Microsoft来说要稍简单一些。在所有场合其实现方式都是一样的。而且这样的实现也带来多一些灵活性。这一点下面“陷阱”一节再进行说明。
GCC在不同的平台其实现细节可能略有不同,我们来看一个基于Intel平台的典型实现:
//source code int test_fun(Base *pb, int { return } //assembly 8048478: push %ebp 8048479: mov 804847b: sub 804847e: mov 8048481: mov 8048484: mov 8048487: mov 804848d: mov 8048490: and 8048493: test 8048495: je 80484b6
; virtual fun,是虚拟函数,计算函数地址 8048497: mov 804849d: add 80484ae: mov 80484b1: mov 80484b4: jmp 80484bc
; 80484b6: mov 80484b9: mov
; common invoking ; 80484bc: push 80484be: mov 80484cb: leave 80484cc: ret 80484cd: nop |
按照C++语言的规定,对于成员函数指针的使用,有如下限制:
不允许继承类的成员函数指针赋值给基类成员函数指针。
如果我们一定要反其道而行,则存在this指针调整的陷阱,需要注意。这一节我们通过两个例子,说明为什么这样操作是危险的。
先看一个单继承的例子。
class B { public: B():m_b(0x13572468){} /* virtual */ int b_fun(int) { //A std::cout<<'B'< return 0; } private: int m_b; }; class D : public B { public: D():m_d(0x24681357){} virtual int foo(int) { // B std::cout<<'D'< return 0; } private: int m_d; }; void test_consistent(B* pb, { (pb->*pmf)(0x12345678); } void test_main(D *pd) { typedef int (B::*B_PMF)(int); //test_consistent(pd, test_consistent(pd, // crash in MSVC } int main() { D d; test_main(&d); return 0; } |
这句话在Microsoft Visual C++6.0下面一运行就crash。 表面上看我们传的指针是D的指针,函数也是D的函数。但实际上不是那么简单。函数调用的时候,pd赋值给pb,编译器会进行this指针调整,pb指向pd内部B的子对象。这样到了test_consistent函数内部的时候,就是用D::B对象调用D::foo函数,this指针不对,所以就crash了。
|
上面这个问题,GCC能正确的进行处理。其实错误的原因不在于pb=pd指针赋值的时候,编译器将指针进行了调整,而在于在test_consistent内,成员函数指针被调用的时候,应该将this指针再调整回去!这个问题又是由static_cast的行为不适当引起的。
static_cast
这里的static_cast,
是将D的成员函数指针强制转换为给B的成员函数指针。因为它是D的函数,虽然会经由B的指针或者对象调用,但是调用时this指针应该根据B的地址调整成D的首地址。所以经过static_cast之后,这个成员函数指针应该为{__pfn, __delta= -4 }。(B被包含在D内部,所以这里是-4!) GCC正确的执行了这个cast,并且每次使用成员函数指针调用时都进行this指针调整, 所以没有问题。可是Microsoft的实现在这个地方却无能为力,为什么呢?就算static_cast正确,在test_consistent里面根本就不会进行this指针调整! 因为它使用的其实是 struct{void *vcall_address;}这个结构,根本不知道要进行this指针调整。
Microsoft在这里要做的是将一个struct pmf_type2类型的对象,通过static_cast转换成一个struct pmf_type1的对象。这种转换根本不能成功,因为struct pmf_type1要少一个成员delta.这样的转换会丢失信息。
当然我们不能怪Microsoft,C++语言本来就规定了不能这样用。不过Microsoft可以做得更好一点,至少可以不允许这样的static_cast。(这样的用法, VC2005能够给出一个告警,提示有可能产生不正确的代码!)
我们可以很简单的解决这个问题,在上面的代码中A处,把注释掉的virtual打开,也可以把B处的virtual注释掉,使得所有地方都无需进行this调整,问题也就不再出现了。
这个例子可能有些牵强,我们把上面的代码稍做修改,再举一个涉及到多继承的例子。
class B { public: B():m_b(0x13572468){} virtual int b_fun(int) { std::cout<<"B return 0; } private: int m_b; }; class B2 { public: B2():m_b2(0x24681357){} int b2_fun(int) { std::cout<<"B2 return 0; } private: int m_b2; }; class D :public B , public B2 { public: D():m_d(0x24681357){} int foo(int) { std::cout<<"D return 0; } private: int m_d; }; void test_consistent(B* pb, int (B::*pmf)(int)) { (pb->*pmf)(0x12345678); } void test_main(D *pd) { typedef int //test_consistent(pd, &B2::b2_fun); //A //test_consistent(pd, static_cast 我们在微信上24小时期待你的声音 解答本文疑问/技术咨询/运营咨询/技术建议/互联网交流 |