求索阁

一、引入继承的目的

1. 代码重用

        类的继承和派生机制，使程序员无需修改已有类，只需在已有类的基础上，通过增加少量代码或修改少量代码的方法得到新的类，从而较好地解决了代码重用的问题。

2. 代码的扩充

        只有在派生类中通过添加新的成员，加入新的功能，类的派生才有实际意义。

二、派生类的声明格式（单继承）

[cpp] view plaincopy

1. class 派生类名：继承方式 基类名 
3. { 
5. //派生类新增的数据成员和成员函数
7. }; 

1）基类名是一个已经定义的类的名字，也可称为父类；

2）派生类名是继承原有类的特性而生成的新类的名称；

3）继承方式规定了如何访问从基类继承的成员，指定了派生类成员以及对象对于基类继承来的成员的访问权限，它包括关键字private、protected、public（分别表示私有、保护、公有继承）。

4） 如果不显示地给出继承方式关键字，系统默认为私有继承（private）。

三、基类成员在派生类中的访问属性

1. 从基类成员属性看

1）当基类成员在基类中的访问属性为private时，

          在三种继承方式的派生类中的访问属性都不可直接访问；

2）当基类成员在基类中的访问属性为public时，

          继承方式为public,在派生类中的访问属性为public，
          继承方式为private,在派生类中的访问属性为private，
          继承方式为protected,在派生类中的访问属性为protected；

3）当基类成员在基类中的访问属性为protected时，

          继承方式为public,在派生类中的访问属性为protected，
          继承方式为private,在派生类中的访问属性为private，
          继承方式为protected,在派生类中的访问属性为protected。  

基类成员在基类中访问属性

基类成员在派生类中访问属性

public

private

protected

public

public

private

protected

private

不可直接访问

不可直接访问

不可直接访问

protected

protected

private

protected

2. 从继承方式看

1）当继承方式为private时，

          基类成员属性为public和protected,则在派生类中的访问属性为private,
          基类成员属性为private,则在派生类中的访问属性为不可直接访问;

2）当继承方式为public时，

          基类成员属性为public和protected,则在派生类中的访问属性为不变,
          基类成员属性为private,则在派生类中的访问属性为不可直接访问;

3）当继承方式为protected时，

          基类成员属性为public和protected,则在派生类中的访问属性为protected,
          基类成员属性为private,则在派生类中的访问属性为不可直接访问。

派生类的继承方式

基类成员在基类中访问属性

public

private

protected

public

public

不可直接访问

protected

private

private

不可直接访问

private

protected

protected

不可直接访问

protected

四、派生类的构造函数和析构函数（单继承）

1. 说明：

1）基类的构造函数和析构函数不能被继承；

2）在派生类中，若对派生类中新增的成员进行初始化，就需要加入派生类的构造函数；

3）对所有从基类继承下来的成员的初始化工作，由基类的构造函数完成；

4）当基类含有带参数的构造函数时，派生类必须定义构造函数，以对基类的构造函数所需要的参数进行设置；

5）当基类的构造函数没有参数，或没有显式定义构造函数时（即使用默认构造函数），派生类可以不向基类传递参数，甚至可不定义构造函数；

6）若派生类的基类也是一个派生类，则每个派生类只需负责其直接基类的构造，一次上溯；

7）派生类与基类的析构函数是独立的（因为析构函数不带参数，故基类的析构函数不会因为派生类没有析构函数而得不到执行）。

2.构造函数和析构函数的执行顺序：

1）当创建派生类对象时，首先执行基类的构造函数，随后再执行派生类的构造函数；

2）当撤销派生类对象时，则先执行派生类的析构函数，随后再执行基类的析构函数。

例子：              

[cpp] view plaincopy

1. #include <iostream.h>
3. class KBase 
4. { 
5. public: 
6.     KBase()      //基类的构造函数
7.     { 
8.         cout<<"Constructing base class/n"; 
9.     } 
11.     ~KBase()     //基类的析构函数
12.     { 
13.         cout<<"Destructing base class/n"; 
14.     } 
15. }; 
17. class KDerive1:public KBase 
18. { 
19. public: 
20.     KDerive1()    //派生类1的构造函数
21.     { 
22.         cout<<"Constructing derive1 class/n"; 
23.     } 
25.     ~KDerive1()   //派生类1的析构函数
26.     { 
27.         cout<<"Destructing derive1 class/n"; 
28.     } 
29. }; 
31. class KDerive2:public KDerive1 
32. { 
33. public: 
34.     KDerive2()    //派生类2的构造函数
35.     { 
36.         cout<<"Constructing derive2 class/n"; 
37.     } 
39.     ~KDerive2()   //派生类2的析构函数
40.     { 
41.         cout<<"Destructing derive2 class/n"; 
42.     } 
43. }; 
45. class KDerive3:public KDerive2 
46. { 
47. public: 
48.     KDerive3()   //派生类3的构造函数
49.     { 
50.         cout<<"Constructing derive3 class/n"; 
51.     } 
53.     ~KDerive3()  //派生类3的析构函数
54.     { 
55.         cout<<"Destructing derive3 class/n"; 
56.     } 
57. }; 
59. int main() 
60. { 
61.     KDerive3 obj; 
62. return 0; 
63. } 

程序结果：

                              Constructing base class

                              Constructing derive1 class
                              Constructing derive2 class
                              Constructing derive3 class
                              Destructing derive3 class
                              Destructing derive2 class
                              Destructing derive1 class
                              Destructing base class

3. 当派生类中含有内嵌对象成员时，构造函数的执行顺序：

1）首先调用基类的构造函数，

2）其次调用内嵌对象成员的构造函数（有多个对象成员时，调用顺序由它们在类中声明的顺序确定），

3）最后执行派生类的构造函数体中的内容。

4）撤销对象时，析构函数的调用顺序与构造函数的调用顺序正好相反。

4. 构造规则

4.1. 派生类构造函数的一般格式：

[cpp] view plaincopy

1. 派生类名（参数总表）：基类名（参数表） 
3. { 
5. //派生类新增成员的初始化语句
7. } 

注：基类构造函数的参数，通常来源于派生类构造函数的参数总表，也可用常数值。

4.2. 当派生类中含有内嵌对象成员时，其构造函数的一般形式：

[cpp] view plaincopy

1. 派生类名（参数总表）：基类名（参数表1），内嵌对象名1（内嵌对象参数表1），……，内嵌对象名n（内嵌对象参数表n） 
3. { 
5. //派生类新增成员的初始化语句
7. } 

4.3. 例子：                       

[cpp] view plaincopy

1. #include <iostream.h>
3. class KBase 
4. { 
5. private: 
6. int x; 
7. public: 
8.     KBase(int i) 
9.     { 
10.         x = i; 
11.         cout<<"Constructing base class/n"; 
12.     } 
14.     ~KBase() 
15.     { 
16.         cout<<"Destructing base class/n"; 
17.     } 
19. void Show() 
20.     { 
21.         cout<<" x = "<<x<<endl; 
22.     } 
23. }; 
25. class KDerived:public KBase 
26. { 
27. private: 
28.     KBase d;    //基类对象d作为派生类的对象成员
29. int y; 
30. public: 
31. //派生类嵌有对象成员时的构造函数格式
32.     KDerived(int i, int j, int k):KBase(i),d(j) 
33.     { 
34.         y = k; 
35.         cout<<"Constructing derived class/n"; 
36.     } 
38.     ~KDerived() 
39.     { 
40.         cout<<"Destructing derived class/n"; 
41.     } 
43. void Show() 
44.     { 
45.         KBase::Show(); 
46.         d.Show(); 
47.         cout<<" y = "<<y<<endl; 
48.     } 
49. }; 
51. int main() 
52. { 
53.     KDerived obj(4,6,8); 
54.     obj.Show(); 
55. return 0; 
56. } 

程序结果：

                                             Constructing base class

                                             Constructing base class

                                             Constructing derived class

                                             x = 4

                                             x = 6

                                             y = 8

                                             Destructing derived class

                                             Destructing base class

                                             Destructing base class

五、派生类成员覆盖基类的同名成员

1. 含义：

        在派生类中定义了与基类同名的成员，称为派生类成员覆盖基类的同名成员。

2. 在派生类中使用基类的同名成员的方法：

        2.1   基类名：：成员名；

        2.2   派生类的对象名.基类名：：成员名；

3. 例子：

[cpp] view plaincopy

1. #include <iostream.h>
2. #include <string.h>
4. //类Student
5. class KStudent  
6. { 
7. private: 
8. char *name; 
9. char *stu_no; 
10. float score; 
11. public: 
12.     KStudent(char *name1, char *stu_no1, float score1); 
13.     ~KStudent(); 
14. void Show(); 
15. }; 
17. KStudent::KStudent(char *name1, char *stu_no1, float score1) 
18. { 
19.     name = new char[strlen(name1) + 1]; 
20.     strcpy(name, name1); 
21.     stu_no = new char[strlen(stu_no1) + 1]; 
22.     strcpy(stu_no, stu_no1); 
23.     score = score1; 
24. } 
26. KStudent::~KStudent() 
27. { 
28. delete []name; 
29. delete []stu_no; 
30. } 
32. void KStudent::Show() 
33. { 
34.     cout<<"/n name: "<<name; 
35.     cout<<"/n stu_no: "<<stu_no; 
36.     cout<<"/n score: "<<score; 
37. } 
39. //类KUstudent
40. class KUstudent:public KStudent 
41. { 
42. private: 
43. char *major; 
44. public: 
45.     KUstudent(char *name1, char *stu_no1, float score1, char *major1); 
46.     ~KUstudent(); 
47. void Show();      //在派生类中，重新定义了成员函数Show()
48. }; 
50. KUstudent::KUstudent(char *name1, char *stu_no1, float score1, char *major1) 
51. :KStudent(name1, stu_no1, score1) 
52. { 
53.     major = new char[strlen(major1) + 1]; 
54.     strcpy(major, major1); 
55. } 
57. KUstudent::~KUstudent() 
58. { 
59. delete []major; 
60. } 
62. void KUstudent::Show() 
63. { 
64.     KStudent::Show();   //定义派生类时，访问基类的同名成员的格式
65.     cout<<"/n major: "<<major<<endl; 
66. } 
68. int main() 
69. { 
70.     KUstudent stu1("Liming", "990201", 90, "computer"); 
71.     stu1.Show(); 
72.     stu1.KStudent::Show();//派生类对象访问基类的同名成员的格式
73. return 0; 
74. }  

程序结果：

                                      name: Liming

                                      stu_no: 990201

                                      score: 90

                                      major: computer

                                      name: Liming

                                      stu_no: 990201

                                      score: 90

六、访问声明

1. 格式：（在私有派生类的同名段中）

       基类名：：基类的成员函数名（或数据成员名）；

2. 说明：

1）数据成员和函数成员均可使用访问声明；

2）访问声明的方法针对私有派生类、基类的保护成员或公有成员（不能访问基类的私有成员）；

3）访问声明必须写在派生类定义式中的同名段中；

4）访问声明不能改变类成员原来在基类中的成员性质，只能把原基类的保护成员调整为派生类的保护成员，原基类的公有成员调整为派生类的公有成员；

5）访问声明机制可个别调整私有派生类从基类继承下来的成员性质，从而使外界可通过派生类的界面直接访问基类的某些成员，同时不影响其他基类成员的封闭性；

6）注意函数的访问声明的格式中不带返回类型和参数（既不能写出返回类型和括号）； 

7）对于重载函数使用访问声明时要慎重（因为对于基类中的重载函数名，访问声明将对基类中所有同名函数起作用）。    

3. 例子：

[cpp] view plaincopy

1. #include <iostream.h>
3. class KA 
4. { 
5. private: 
6. int x; 
7. public: 
8.     KA(int x1) 
9.     { 
10.         x = x1; 
11.     } 
13. void Print() 
14.     { 
15.         cout<<" x = "<<x; 
16.     } 
17. }; 
19. class KB:private KA 
20. { 
21. private: 
22. int y; 
23. public: 
24.     KB(int x1, int y1):KA(x1) 
25.     { 
26.         y = y1; 
27.     } 
29.     KA::Print;  //访问声明，这时Print也就成为了类KB的公有成员
30. }; 
32. int main() 
33. { 
34.     KB b(10,20); 
35.     b.Print(); 
36. return 0; 
37. } 

程序结果：x = 10

七、多重继承

1. 声明格式：

[cpp] view plaincopy

1. class 派生类名：继承方式1 基类名1，……，继承方式n 基类名n 
3. { 
5. //派生类新增的数据成员和成员函数
7. }; 

2. 说明：

1）默认的继承方式是private；

2）在多重继承中，公有继承和私有继承对于基类成员在派生类中的可访问性与单继承的规则相同。

3. 构造函数和析构函数

3.1. 构造函数定义格式：

[cpp] view plaincopy

1. 派生类名（参数总表）：基类名1（参数表1），基类名2（参数表2），……，基类名n（参数表n） 
3. { 
5. //派生类新增成员的初始化语句
7. }; 

3.2. 构造函数的执行顺序：（与单继承构造函数的执行顺序相同）

1）首先执行基类的构造函数（处于同一层次的各个基类的构造函数的执行顺序，取决于声明派生类时所指定的各个基类的顺序，与派生类构造函数中所定义的成员初始化列表的各项顺序没有关系）；

2）再执行对象成员的构造函数；

3）最后执行派生类构造函数。

4） 析构函数的执行顺序刚好与构造函数的执行顺序相反。

3.3. 说明：

1）多重继承下派生类构造函数与单继承下派生类构造函数相似，它必须同时负责该派生类所有基类构造函数的调用，同时，派生类的参数个数必须包含完成所有基类初始化所需的参数个数；

3.4. 例子：   

[cpp] view plaincopy

1. #include <iostream.h>
3. class KX 
4. { 
5. private: 
6. int a; 
7. public: 
8.     KX(int sa) 
9.     { 
10.         a = sa; 
11.         cout<<"Constructing class KX/n"; 
12.     } 
14.     ~KX() 
15.     { 
16.         cout<<"Destructing class KX/n"; 
17.     } 
19. int GetX() 
20.     { 
21. return a; 
22.     } 
23. }; 
25. class KY 
26. { 
27. private: 
28. int b; 
29. public: 
30.     KY(int sb) 
31.     { 
32.         b = sb; 
33.         cout<<"Constructing class KY/n"; 
34.     } 
36.     ~KY() 
37.     { 
38.         cout<<"Destructing class KY/n"; 
39.     } 
41. int GetY() 
42.     { 
43. return b; 
44.     } 
45. }; 
47. class KZ:public KX, private KY 
48. { 
49. private: 
50. int c; 
51. public: 
52.     KZ(int sa, int sb):KX(sa), KY(sb) 
53.     { 
54.         c = sb; 
55.         cout<<"Constructing class KZ/n"; 
56.     } 
58.     ~KZ() 
59.     { 
60.         cout<<"Destructing class KZ/n"; 
61.     } 
63. int GetZ() 
64.     { 
65. return c; 
66.     } 
68. /*int GetY()  //采用重载的方式使函数GetY()成为类KZ的公有成员
69.     {
70.         return KY::GetY();
71.     }*/
72.     KY::GetY;    //采用访问声明的方式使函数GetY()成为类KZ的公有成员
73. }; 
75. int main() 
76. { 
77.     KZ obj(2,4); 
78. int ma = obj.GetX(); 
79.     cout<<"a = "<<ma<<endl; 
80. int mb = obj.GetY(); 
81.     cout<<"b = "<<mb<<endl; 
82. int mc = obj.GetZ(); 
83.     cout<<"c = "<<mc<<endl; 
84. return 0; 
85. } 

程序结果：

                                        Constructing class KX

                                        Constructing class KY

                                        Constructing class KZ

                                        a = 2

                                        b = 4

                                        c = 4     

                                        Destructing class KZ

                                        Destructing class KY

                                        Destructing class KX