基类指针和派生类指针

基类指针指向派生类对象

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

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

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

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

总结：基类指针和派生类指针指向基类对象和派生类对象的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.   
124.     Base1 b1;  
125.     Derived1 d1;  
126.     useBase1Obj(b1);//基类实参-基类形参，调用基类函数  
127.     useBase1Obj(d1);//派生类实参-基类形参，发生派生类到基类的转化，调用基类  
128. //  useDerivedObj((Derived)b);//基类实参，派生类形参，无法类型转化，函数报错  
129.     useDerived1Obj(d1);//派生类实参-派生类形参，调用派生类函数  
130.     cout<<endl;  
131.   
132.     Base1 *pb1 = &b1;   //b1的实际类型为基类，它的虚函数表指明了如果通过指针或者引用调用自己，使用基类的方法  
133.     Derived1 *pd1 = &d1;//d1的实际类型为派生类，它的虚函数表指明了如果通过指针或者引用调用自己，使用派生类方法  
134.     useBase1Ptr(pb1);   //通过虚函数表查得，对于pb1应该调用基类的方法  
135.     useBase1Ptr(pd1);   //通过虚函数表查得，对于pd1应该调用基类的方法  
136. //  useDerivedPtr(pb1); //指向基类的实参，指向派生类形参，不匹配  
137.     useDerived1Ptr((Derived1*)pb1); //通过强制类型转换使其匹配，调用基类函数  
138.                                     //强制类型转化并没有修改虚函数表的内容，所以还是调用基类的方法  
139.   
140.   
141.     useDerived1Ptr(pd1);//通过虚函数表查得，调用派生类的方法  
142.     cout<<endl;  
143.   
144.     pb1 = new Derived1; //形参静态类型为基类，动态类型为派生类，虚函数表中指明了遇见它调用派生类函数  
145.     useBase1Ptr(pb1);   //使用派生类方法  
146.     useDerived1Ptr((Derived1*)pb1);//使用派生类方法  
147.     return 0;  
148. }  

大部分内容其中注释都说清楚了，下面总结如下：

1.对于基类与派生类对象之间：派生类对象可以用来当做基类对象使用，完成基类的功能，不需要类型转化。反之则不成立，需要一个派生类对象的地方，不能填入一个基类对象。

2.对于指针和引用，分为两种情况：

(a)没有虚函数：此时，调用基类还是派生类完全取决于函数形参的静态类型。如果形参与实参类型不符，需要类型转化：派生类指针转化为基类指针，由编译器自动完成；而基类指针转化为派生类，则必须强制完成。其中后者可能是不安全的。比如我们程序中的那个打印结果为随机数。因为这里试图访问一个基类中并不存在的内容。通常，如果使用C++的类型转化操作：dynamic_cast可以解决这个问题，如果从基类向派生类转化，则会转化失败，dynamic_cast会返回一个空指针；而对应的引用操作则会抛出异常。

(2)有虚函数：此时，函数的调用是通过虚函数表来完成的。每次通过指针或者引用调用它时，都调用的是它实际类型的函数。如果形参与实参类型不符，可以通过强制类型转化来完成匹配，但即使强制类型转化后，并没有改变虚函数表里面的内容，所以不管你如何转化，都调用的它实际指向对象的那个函数。

如果在基类中成员函数为虚函数,
那么通过基类指针调用的就是派生类的成员函数,
若该函数为非虚函数,则调用的是基类的成员函数.
记忆深刻啊1!!!!!!!
#include<iostream>
using namespace std;
class base
{
public:
virtual void display(){cout<<"The base's display function called!"<<endl;}
void show(){cout<<"The base's show function called!"<<endl;}
};
class derive:public base
{
public:
void display(){cout<<"The derive's display function called!"<<endl;}
void show(){cout<<"The derive's show function called!"<<endl;}
};

int main()
{
base *bptr;
derive test;
bptr=&test;
bptr->display();
bptr->show();
return 0;
}

一：继承中的指针问题。
1． 指向基类的指针可以指向派生类对象，当基类指针指向派生类对象时，这种指针只能访问派生对象从基类继承而来的那些成员，不能访问子类特有的元素，除非应用强类型转换，例如有基类B和从B派生的子类D，则B *p;D dd; p=&dd;是可以的，指针p只能访问从基类派生而来的成员，不能访问派生类D特有的成员．因为基类不知道派生类中的这些成员。
2． 不能使派生类指针指向基类对象．
3． 如果派生类中覆盖了基类中的成员变量或函数，则当声明一个基类指针指向派生类对象时，这个基类指针只能访问基类中的成员变量或函数。例如：基类B和派生类D都定义了函数f，则B *p; D m; p=&m; m.f()将调用基类中的函数f()而不会调用派生类中的函数f()。
4． 如果基类指针指向派生类对象，则当对其进行增减运算时，它将指向它所认为的基类的下一个对象，而不会指向派生类的下一个对象，因此，应该认为对这种指针进行的增减操作是无效的．
二：虚函数
1． 为什么要使用虚函数：正如上面第1和3点所讲的，当声明一个基类指针指向派生类对象时，这个基类指针只能访问基类中的成员函数，不能访问派生类中特有的成员变量或函数。如果使用虚函数就能使这个指向派生类对象的基类指针访问派生类中的成员函数，而不是基类中的成员函数，基于这一点派生类中的这个成员函数就必须和基类中的虚函数的形式完全相同，不然基类指针就找不到派生类中的这个成员函数。使用虚函数就实现了一个接口多种方法。