基类指针和派生类指针

Posted 2022-10-22 zhanghuan_wangkai

基类指针指向派生类对象

派生类对象也“是”基类对象，但两者不同。

派生类对象可以当做基类对象，这是因为派生类包含基类的所有成员。

但是基类对象无法被当做成派生类对象，因为派生类可能具有只有派生类才有的成员。

所以，将派生类指针指向基类对象的时候要进行显示的强制转换，否则会使基类对象中的派生类成员成为未定义的。

总结：基类指针和派生类指针指向基类对象和派生类对象的4中方法：

1.  基类指针指向基类对象，简单。只需要通过基类指针简单地调用基类的功能。

2.  派生类指针指向派生类对象，简单。只需要通过派生类指针简单地调用派生类功能。

3.  将基类指针指向派生类对象是安全的，因为派生类对象“是”它的基类的对象。

但是要注意的是，这个指针只能用来调用基类的成员函数。

如果试图通过基类指针调用派生类才有的成员函数，则编译器会报错。

为了避免这种错误，必须将基类指针强制转化为派生类指针。然后派生类指针可以用来调用派生类的功能。这称为向下强制类型转换，这是一种潜在的危险操作。

注意：如果在基类和派生来中定义了虚函数（通过继承和重写），并同过基类指针在派生类对象上调用这个虚函数，则实际调用的是这个函数的派生类版本。

4.  将派生类指针指向基类对象，会产生编译错误。“是”关系只适用于从派生类到它的直接（或间接）基类，反过来不行。

 基类对象并不包含派生类才有的成员，这些成员只能通过派生类指针调用。

先上一段代码：

[cpp]

  view plain  copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. //没有使用虚函数的继承派生关系  
5. class Base  
6.   
7. public:  
8.     Base(int i = 0):ival(i)  
9.     void getVal()  
10.       
11.         cout<<ival<<endl;  
12.       
13. private:  
14.     int ival;  
15. ;  
16.   
17. class Derived:public Base  
18.   
19. public:  
20.     Derived(int i = 0, int j = 1):Base(i),ival(j)  
21.     void getVal()  
22.       
23.         cout<<ival<<endl;  
24.       
25. private:  
26.     int ival;  
27. ;  
28.   
29. //使用了虚函数的继承派生关系  
30. class Base1  
31.   
32. public:  
33.     Base1(int i = 0):ival(i)  
34.     virtual void getVal()  
35.       
36.         cout<<ival<<endl;  
37.       
38. private:  
39.     int ival;  
40. ;  
41.   
42. class Derived1:public Base1  
43.   
44. public:  
45.     Derived1(int i = 0, int j = 1):Base1(i),ival(j)  
46.     void getVal()  
47.       
48.         cout<<ival<<endl;  
49.       
50. private:  
51.     int ival;  
52. ;  
53.   
54.   
55. void useBaseObj(Base b)  
56.   
57.     b.getVal();  
58.   
59.   
60. void useDerivedObj(Derived d)  
61.   
62.     d.getVal();  
63.   
64.   
65. void useBasePtr(Base *pb)  
66.   
67.     pb->getVal();  
68.   
69.   
70. void useDerivedPtr(Derived *pd)  
71.   
72.     pd->getVal();  
73.   
74.   
75. void useBase1Obj(Base1 b)  
76.   
77.     b.getVal();  
78.   
79.   
80. void useDerived1Obj(Derived1 d)  
81.   
82.     d.getVal();  
83.   
84.   
85. void useBase1Ptr(Base1 *pb)  
86.   
87.     pb->getVal();  
88.   
89.   
90. void useDerived1Ptr(Derived1 *pd)  
91.   
92.     pd->getVal();  
93.   
94.   
95. int main()  
96.   
97.     Base b;  
98.     Derived d;  
99.   
100.     Base *pb = &b;  
101.     Derived *pd = &d;  
102.     useBaseObj(b);//基类实参，基类形参，调用基类函数  
103.     useBaseObj(d);//派生类实参，基类形参，自动转化，调用基类函数  
104. //  useDerivedObj((Derived)b);//无法用基类(自动的)构造出一个派生类  
105.     useDerivedObj(d);//派生类实参，派生类形参，调用派生类函数  
106.     cout<<endl;  
107.   
108.     useBasePtr(pb);//指向基类形参，指向基类实参，调用基类函数  
109.     useBasePtr(pd);//指向基类形参，指向派生类实参，调用静态类型-基类函数  
110. //  useDerivedPtr(pb);//指向基类实参，指向派生类形参，无法自动转化  
111.     useDerivedPtr((Derived*)pb);//强制类型转化，打印结果为随机数  
112.                                 //为什么？  
113.                                 //因为程序试图访问一个自己并没有的成员  
114.     useDerivedPtr(pd);//指向派生类实参，指向派生类形参，调用派生类  
115.     cout<<endl;  
116.   
117.     pb = new Derived;//静态类型为指向基类，动态类型为指向派生类  
118.     useBasePtr(pb);//形参为指向基类指针，实参静态类型为指向基类指针，调用基类函数  
119.     useDerivedPtr((Derived*)pb);//形参类型为指向派生类指针，实参静态类型为指向基类的指针  
120.                                 //但是由于内存中的确有这个数（因为我们实际new的是一个派生类）  
121.                                 //所以结果为派生类函数  
122.     cout<<endl;  
123. 基类指针和派生类指针

     基类指针指向派生类对象&派生类指针指向基类对象

     虚函数和基类中的this指针的问题！

     派生类和基类的转换

     使用具有指向派生类对象的指针的基类指针数组调用派生类方法

     知道基类指针指向哪个派生类