C++中的多重继承（二）

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class BaseA
 7 {
 8 public:
 9     virtual void funcA()
10     {
11         cout << "BaseA::funcA()" << endl;
12     }
13 };
14 
15 class BaseB
16 {
17 public:
18     virtual void funcB()
19     {
20         cout << "BaseB::funcB()" << endl;
21     }
22 };
23 
24 class Derived : public BaseA, public BaseB
25 {
26 
27 };
28 
29 int main()
30 {
31     Derived d;
32     BaseA* pa = &d;
33     BaseB* pb = &d;
34     BaseB* pbe = (BaseB*)pa;    // 忘记这种转换方式
35     BaseB* pbc = dynamic_cast<BaseB*>(pa);    // 用这种转换方式
36     
37     cout << "sizeof(d) = " << sizeof(d) << endl;  // 这是虚函数表指针定义的；
38     
39     cout << "Using pa to call funcA()..." << endl;
40     
41     pa->funcA();  // BaseA::funcA()
42     
43     cout << "Using pb to call funcB()..." << endl;
44     
45     pb->funcB();  // BaseB::funcB()
46     
47     cout << "Using pbe to call funcB()..." << endl;
48     
49     pbe->funcB(); // BaseB::funcA()  pa 和 pb 都指向同一个对象，但是保存的值不一样，具体见 4 中分析；
50     
51     cout << "Using pbc to call funcB()..." << endl;
52     
53     pbc->funcB();  // BaseB::funcb()  // 使用了 dynamic_cast，编译器就会检查 pa 指向的指针是 d 对象，进而检查d 对象有 BaseA 和 BaseB，进而认为这里转换合法，并且对指针有个修正，使得pbb 指向 pb 的位置，则调用正确；
54     
55     cout << endl;
56     
57     cout << "pa = " << pa << endl;  // 0xbfd11238
58     cout << "pb = " << pb << endl;  // 0xbfd1123c
59     cout << "pbe = " << pbe << endl;  // 0xbfd11238  没有修正
60     cout << "pbc = " << pbc << endl;  // 0xbfd1123c；做了修正
61     
62     return 0;
63 }

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Base
 7 {
 8 protected:
 9     int mi;
10     
11 public:
12     Base(int i)
13     {
14         mi = i;
15     }
16     
17     int getI()
18     {
19         return mi;
20     }
21     
22     /* 在顶层父类中，定义函数判断参数指针指向的是不是当前对象（用法见 main() 函数），解决多重继承的问题一 */
23     bool equal(Base* obj)  // 传递的指针要加上 dynamic_cast 强制类型转换；
24     {
25         return (this == obj);
26     }
27 };
28 
29 /* 加减接口 */
30 class Interface1
31 {
32 public:
33     virtual void add(int i) = 0;
34     virtual void minus(int i) = 0;
35 };
36 
37 /* 乘除接口 */
38 class Interface2
39 {
40 public:
41     virtual void multiply(int i) = 0;
42     virtual void divide(int i) = 0;
43 };
44 
45 /* 单继承、实现多个接口 */
46 class Derived : public Base, public Interface1, public Interface2  // 表象上依然是 C++ 中的多继承，但是整个程序的语义上来看是单继承加上实现多个接口；
47 {
48 public:
49     Derived(int i) : Base(i)
50     {
51     }
52     
53     void add(int i)  // 实现接口中的加法
54     {
55         mi += i;
56     }
57     
58     void minus(int i)  // 实现接口中的加法
59     {
60         mi -= i;
61     }
62     
63     void multiply(int i)  // 实现接口中的加法
64     {
65         mi *= i;
66     }
67     
68     void divide(int i)  // 实现接口中的加法
69     {
70         if( i != 0 )
71         {
72             mi /= i;
73         }
74     }
75 };
76 
77 int main()
78 {
79     Derived d(100);
80     Derived* p = &d;
81     Interface1* pInt1 = &d;
82     Interface2* pInt2 = &d;
83     
84     cout << "p->getI() = " << p->getI() << endl;    // 100
85     
86     pInt1->add(10);
87     pInt2->divide(11);
88     pInt1->minus(5);
89     pInt2->multiply(8);
90     
91     cout << "p->getI() = " << p->getI() << endl;    // 40
92     
93     cout << endl;
94     
95     cout << "pInt1 == p : " << p->equal(dynamic_cast<Base*>(pInt1)) <<     endl;  // 打印 1，不转换则报错，没有这样的函数可以调用
96     cout << "pInt2 == p : " << p->equal(dynamic_cast<Base*>(pInt2)) <<     endl;  // 打印 1，不转换则报错，没有这样的函数可以调用
97     
98     return 0;
99 }