怎么感觉成员函数问题有些混乱了呢。

Utunnels

刚写了下看看。
class B和C都继承A。现在实例化C，然后用一个A成员函数指针指向B的成员函数（类型转换），然后用C的实例调用，于是相当于C的实例调用了B的成员函数。

弹出的对话框标题为"this is B::bfunc"，内容却是C的private成员"ccc"。

1. 
   
2. #include <windows.h>
   
3. 
   
4. class A
   
5. {
   
6. private:
   
7.         LPSTR s;
   
8. public:
   
9.         A(){s="aaa";}
   
10.         void afunc()
    
11.         {
    
12.                 MessageBox(NULL,s,"this is A::afunc",MB_OK);
    
13.         }
    
14. };
    
15. 
    
16. [color=#339900]/*B继承A*/[/color]
    
17. class B:public A
    
18. {
    
19. private:
    
20.         LPSTR s;
    
21. public:
    
22.         B():A(){s="bbb";}
    
23.         void bfunc()
    
24.         {
    
25.                 MessageBox(NULL,s,"this is B::bfunc",MB_OK);
    
26.         }
    
27. };
    
28. 
    
29. [color=#339900]/*C继承A*/[/color]
    
30. class C:public A
    
31. {
    
32. private:
    
33.         LPSTR s;
    
34. public:
    
35.         C():A(){s="ccc";}
    
36.         void cfunc()
    
37.         {
    
38.                 MessageBox(NULL,s,"this is C::cfunc",MB_OK);
    
39.         }
    
40. };
    
41. 
    
42. 
    
43. 
    
44. typedef void (A::*LPDELEGATEAFUNC)(void);
    
45. 
    
46. [color=#339900]/*WinMain*/[/color]
    
47. int WINAPI WinMain(HINSTANCE hInst,HINSTANCE,LPSTR CmdLine,int CmdShow)
    
48. {
    
49.         [color=#339900]/*实例化C*/[/color]
    
50.         C* c=new C();
    
51.         [color=#339900]/*A成员函数指针指向B的成员函数*/[/color]
    
52.         LPDELEGATEAFUNC pf=(LPDELEGATEAFUNC)B::bfunc;
    
53.         [color=#339900]/*用C的实例调用该函数*/[/color]
    
54.         (c->*pf)();
    
55. 
    
56. }[color=#339900]/*WinMain*/[/color]
    
57. 
    

复制代码

dkxw

无语了。。。你在干什么。。。。LPSTR s相对于this的偏移是一样的，所以你才能这样子。
还有B():A()这样你不觉得。。。
private:        LPSTR s;有必要吗？
protected不就得了？

Utunnels

……我只是在测试。

Utunnels

貌似写成as bs cs更好些，懒得改了，反正结果都是一样的。

EasySL

B::bfunc 所以 使用成员函数指针时要加 B：： 来修饰, 类继承不是动态邦定的,是静态邦定的.
所以 B::修饰只适用于编译期间. 而运行时间是 C::bfunc()

EasySL

最后这个C类 里面有一个B 和一个A,所以,拥有 afunc bfunc 所以存在一个 C::bfunc()

bombbear

再正常不过的情况了。

类B的对象内存布局为：
----------偏移起始
A::s
B::s
----------
类C的对象内存布局为：
----------偏移起始
A::s
C::s
----------

类的成员函数在使用成员变量时以偏移量引用。
B::bfunc中用到的s( B::s )的偏移量转换到C上时恰好对应 C::s。

Utunnels

嗯，这个我知道，只是说这个不算bug的bug。

但是如果没有继承关系的成员函数指针，vc编译的时候完全可以通过，不过调用的时候就不对了。

这个是有继承关系的，编译和运行都可，但是也有潜在的危险（加入我C那个位置是个int，或者干脆什么都没有，就出错了）

那天忽然醒悟，自己原来写的很多代码都是有这种风险的，现在正修改中……

bombbear

在C++中指针退化（从B到A的转换）是安全的，但进化（从A到B或从A到C的转换）是没有任何安全性可言的。
所以C++它老爹告戒我们不要使用指针进化动作，除非1）确切知道是在有效继承链上移动，2）使用了RTTI等技术，3）故意要找点教训。