请教个关于多态的问题

demilich

#include <iostream>
using namespace std;
  
class A
{
public:
     virtual void f()
     {
         cout << "A" << endl;
     }
};
  
class B: public A
{
public:
     virtual void f()
     {
         cout << "B" << endl;
     }
  
     void e()
     {
         cout << x << endl;
     }
private:
     int x;
};
  
int main()
{
     A *pa = new A();
     B *pb = (B*)pa;
     pb->f();
     pb->e();
}
  
输出结果A和0
问题：
1. pb->f()，一般我们调用都是 基类指针->派生类对象，反过来这么操作，一般应该用dynamic_cast对吧？但是就算不用dynamic_cast，用static_cast或者这种传统转型，也应该出错的吧 ...
2. pb->e()，这个就完全无法理解了，这是A的对象啊 ...

MMMIX

demilich 发表于 2015-08-18 15:27

  1. pb->f()，一般我们调用都是 基类指针->派生类对象，反过来这么操作，一般应该用dynamic_cast对吧？

没错, 而且应该写成类似如下的形式:

if (B *pb = dynamic_cast<B *>(pa)) {
    ...
} else {
    ...
}

但是就算不用dynamic_cast，用static_cast或者这种传统转型，也应该出错的吧 ...

都是指针, 而且你都做了强制类型转换了...

2. pb->e()，这个就完全无法理解了，这是A的对象啊 ...

pb->e() 是静态绑定, 根据 pb 的类型找到 e(); pb->f() 是动态绑定, 根据 pb 在运行时指向的对象找到 f().

cokeboL

多恶心的c++。。。我爱c版我不爱c++

demilich

回复 2# MMMIX


    那么问题在于，pb->e(); 里面x的值怎么回事？这个是A对象啊，没有x才对，为什么能打印出来？

lxyscls

回复 1# demilich

1. #include <iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. class A
   
6. {
   
7.     public:
   
8.         virtual void f()
   
9.         {   
   
10.             cout << "A" << endl;
    
11.         }   
    
12. };
    
13. 
    
14. class B: public A
    
15. {   
    
16.     public:
    
17.         virtual void f()
    
18.         {   
    
19.             cout << "B" << endl;
    
20.         }
    
21.         
    
22.         void e()
    
23.         {   
    
24.             cout << x << endl;
    
25.         }
    
26.     private:  
    
27.         int x = 10;
    
28. };
    
29. 
    
30. int main(void)
    
31. {
    
32.     A *pa = new A;      
    
33.     B *pb = (B*)pa;
    
34. 
    
35.     pb->f();
    
36.     pb->e();
    
37. 
    
38.     B *pc = new B();
    
39.     pc->e();
    
40. 
    
41.     return 0;
    
42. }

复制代码

输出是：
A
0
10

GDB：

1. (gdb) b B::e
   
2. Breakpoint 1 at 0x400b1a: file test.cpp, line 24.
   
3. (gdb) r
   
4. Starting program: /root/cpp/test
   
5. A
   
6. 
   
7. Breakpoint 1, B::e (this=0x603010) at test.cpp:24
   
8. 24                              cout << x << endl;
   
9. Missing separate debuginfos, use: debuginfo-install glibc-2.18-19.fc20.x86_64 libgcc-4.8.3-7.fc20.x86_64 libstdc++-4.8.3-7.fc20.x86_64
   
10. (gdb) p &x
    
11. $1 = (int *) 0x603018
    
12. (gdb) x/10 0x603018
    
13. 0x603018:       [color=Red]0[/color]       0       0       0
    
14. 0x603028:       135137  0       0       0
    
15. 0x603038:       0       0
    
16. (gdb) c
    
17. Continuing.
    
18. 0
    
19. 
    
20. Breakpoint 1, B::e (this=0x603030) at test.cpp:24
    
21. 24                              cout << x << endl;
    
22. (gdb) p &x
    
23. $2 = (int *) 0x603038
    
24. (gdb) x/10 0x603038
    
25. 0x603038:       [color=Red]10[/color]      0       0       0
    
26. 0x603048:       135105  0       0       0
    
27. 0x603058:       0       0
    
28. (gdb)

复制代码

bskay

pb->e()
其实是
pb->B::e()

实质是
B::e(pb)

类的成员函数,并不属于任何类的实例,而是独一无二的独立的函数
只不过编译器,把this指针隐式的传给它,也就是说语法上的B::e(),其实第一个参数是B*
.....看看python之类语法,就明白了

littledick

这样的强转越界访问，一旦发生bug，绝对会被交叉查错的同事874一百遍啊。

windoze

基类指针转型到子类指针不要用dynamic_cast，应该用static_cast，除非你不确定这个指针是不是真的指向一个子类对象。

littledick

windoze 发表于 2015-08-19 15:24
基类指针转型到子类指针不要用dynamic_cast，应该用static_cast，除非你不确定这个指针是不是真的指向一个子 ...

除非你有确定指针类型的方法，否则，天知道别人在调用你接口时传入的是不是那个子类型。

windoze

回复 10# littledick

转型前你总得猜一下吧，好多地方都有类似的东西：

1. 
   
2. struct Base {
   
3.     virtual int type_tag()=0;
   
4. };
   
5. 
   
6. struct Sub1 : public Base {
   
7.     virtual int type_tag() { return 1; }
   
8. };
   
9. 
   
10. struct Sub2 : public Base {
    
11.     virtual int type_tag() { return 2; }
    
12. };
    
13. 
    
14. ...
    

复制代码

然后用的时候就会这么写：

1. 
   
2. void f(Base *p) {
   
3.     switch(p->type_tag()) {
   
4.     case 1: {
   
5.         Sub1 *ps1=static_cast<Sub1 *>(p);
   
6.         ps1-> ...
   
7.     }
   
8.     case 2: {
   
9.         Sub2 *ps1=static_cast<Sub2 *>(p);
   
10.         ps2-> ...
    
11.     }
    
12.     }
    
13. }
    

复制代码

我知道这段代码很丑，不过重点不在这儿，而是说这段代码里就应该用static_cast，不应该用dynamic_cast

必须用dynamic_cast的地方是这样的：

1. 
   
2. struct Base1 {
   
3.     virtual ~Base1(){}
   
4. };
   
5. struct Base2 {
   
6.     virtual ~Base2(){}
   
7. };
   
8. struct Sub : public Base1, Base2 { ... };
   
9. 
   
10. void f(Base1 *pb1) {
    
11.     Base2 *pb2=dynamic_cast<Base2 *>(pb1);
    
12.     pb2->...
    
13. }
    

复制代码

上面这段代码必须用dynamic_cast，否则就是错的。