c++之虚函数和基类指针

　　1. 基类指针虽然获取派生类对象地址，却只能访问派生类从基类继承的成员

 1 #include <iostream>
 2 using namespace std;
 3 
 4 //经过基类指针只能访问从基类继承的成员
 5 class A
 6 {
 7 public:
 8     A(char x)
 9     {
10         this->x = x;
11     }
12     //void virtual who()    //基类定义虚函数，则派生类的重定义版本默认为虚函数
13     void who()    //除非定义虚函数，不然基类指针没法访问派生类的非继承的成员
14     {
15         cout << "A class" << x << endl;
16     }
17 protected:
18     char x;
19 };
20 
21 class B:public A
22 {
23 public:
24     B(char x,char y):A(x)
25     {
26         this->y = y;
27     }
28     void who()
29     {
30         cout<< "B class" << x << "," << y<< endl;
31     }
32 protected:
33     char y;
34 };
35 class C:public B
36 {
37 public:
38     C(char x,char y,char z):B(x,y)
39     {
40         this->z = z;
41     }
42     void who()
43     {
44         cout<< "C class " << x << "," << y << "," << z << endl;
45     }
46 protected:
47     char z;
48 };
49 
50 void main()
51 {
52     A a('A'); 
53     B b('T','O');
54     C c('E','N','D');
55     //定义基类指针
56     A* aa;
57     aa = &a;
58     aa->who();
59     aa = &b;
60     //只能调用从基类继承的函数
61     aa->who();
62     aa = & c;
63     //只能调用从基类继承的函数
64     aa->who();
65     //经过对象调用自身的成员函数
66     b.who();
67     //基类指针作类型转换，调用转换后的类型的类成员函数
68     ((C*)aa)->who();
69 }

2.虚函数和基类指针

注意：

　　一个虚函数，在派生类层界面相同的重载函数都保持虚特性

　　虚函数必须是类的成员函数

　　不能将友元说明为虚函数，但虚函数能够是另外一个类的友元

　　析构函数能够是虚函数，但构造函数不能是虚函数

3.虚函数的重载特性

 

　　在派生类中重载基类的虚函数要求函数名、返回类型、参数个数、

 

　　参数类型和顺序彻底相同

 

　　若是仅仅返回类型不一样，C++认为是错误重载

 

　　若是函数原型不一样，仅函数名相同，丢失虚特性 

 1 例：
 2 class  base
 3 { public : 
 4       virtual  void  vf1 ( ) ;
 5       virtual  void  vf2 ( ) ;
 6       virtual  void  vf3 ( ) ;
 7       void  f ( ) ;
 8  } ;
 9 class  derived : public  base
10 { public : 
11       void  vf1 ( ) ;        // 虚函数
12       void  vf2 ( int ) ;    // 重载，参数不一样，虚特性丢失
13       char  vf3 ( ) ;        // error，仅返回类型不一样
14       void f ( ) ;        // 非虚函数重载
15  } ;
16 
17 void  g ( ) 
18 { derived   d ;
19    base  * bp = & d ;        // 基类指针指向派生类对象
20    bp -> vf1 ( ) ;            // 调用 deriver :: vf1 ( )
21    bp -> vf2 ( ) ;            // 调用 base :: vf2 ( )
22    bp -> f ( ) ;            // 调用 base :: f ( )
23 } ;