C++ 面向对象的三个特色--继承与封装（一）

面试的时候常常会有不少概念性的东西，许久不用都会很生疏，特地整理一下方便本身之后不记得了能够查看一下，也顺便帮助本身复习一下。

• 概念

继承是面向对象程序设计的一个重要特性，它容许在既有类的基础上建立新的类，新类能够从一个或者是多个既有类中继承函数和数据，还能够从新定义或加入新的数据和函数。

• 基类成员在派生类中的访问属性概括

咱们了解类的成员能够有public、protected、private三种访问属性，类的自身成员能够访问类中的任何成员，可是经过对象访问的话，就只能访问类的public（公有）成员。

类的继承方式有public（公有继承）、protected（保护继承）、private（私有继承）。

在派生类中，基类成员的访问属性能够概括为四种：不可直接访问，public，protected，private。

在基类中的访问属性	继承方式	在派生类中的访问属性
private	public	不可直接访问
private	private	不可直接访问
private	protected	不可直接访问
protected	public	protected
protected	private	private
protected	protected	protected
public	public	public
public	private	private
public	protected	protected

概括一下就是：

（1）. 基类的私有成员

不管是那种继承方式，基类的私有成员都不容许派生类继承。也就是派生类中不可直接访问的。

（2）. 基类的保护成员

公有继承时，基类中得全部公有成员在派生类中以保护成员的身份出现。

保护继承时，基类中得全部保护成员在派生类中以保护成员的身份出现。

私有继承时，基类中得全部私有成员在派生类中以私有成员的身份出现。

（3）. 基类的公有成员

公有继承时，基类中得全部公有成员在派生类中以公有成员的身份出现。

保护继承时，基类中得全部保护成员在派生类中以保护成员的身份出现。

私有继承时，基类中得全部私有成员在派生类中以私有成员的身份出现。

• 派生类对基类成员的访问规则

咱们都知道，派生类对基类的访问形式主要有如下两种方式：（1）.内部访问，有派生类新增的成员对基类继承过来的成员进行访问。（2）.对象访问，在派生类的外部，经过定义派生类的对象来对基类继承来得成员进行访问。

那咱们来分析三种继承方式下面，派生类对基类的访问规则。

i. 私有继承的访问规则

基类成员	Private成员	Public成员	Protected成员
内部访问	不可访问	能够访问	能够访问
对象访问	不可访问	不可访问	不可访问

首先，咱们根据一个具体的例子来看一下。

 1 //基类
 2 class Base
 3 {
 4 public:
 5     Base(int a, int b, int c): x(a),y(b),z(c)
 6     {}
 7     virtual ~Base(void);
 8 
 9     int x;
10     void printX()
11     {
12        printZ();     // 间接的访问基类的private成员
13        printf("X = %d\n", x);
14     }
15 
16 protected:
17     int y;
18     void printY()
19     {
20        printf("Y = %d\n", y);
21     }
22 
23 private:
24     int z;
25     void printZ()
26     {
27        printf("Z = %d\n", z);
28     }
29 };
30 
31 //派生类
32 #include "base.h"
33 
34 class Derivel :
35     private Base
36 {
37 public:
38     Derivel(int a, int b, int c):Base(a,b,c)
39     {}
40     virtual ~Derivel(void);
41 
42     void show()
43     {
44        printX();     // 正确，基类的公有成员，派生类内部访问可能
45        printY();     // 正确，基类的保护成员，派生类内部访问可能
46        printZ();     // 错误，基类的私有成员，派生类不能内部访问
47     }
48 };
49 
50 // main
51 #include "Base.h"
52 #include "Derivel.h"
53 
54 int _tmain(int argc, _TCHAR* argv[])
55 {
56     Derivel a(1,2,3);
57 
58 　　a.printX();     
59     // 错误，基类的公有成员，私有继承后做为派生类的私有成员，不能外部访问
60 　　a.printY();     
61     // 错误，基类的保护成员，私有继承后做为派生类的私有成员，不能外部访问
62 　　a.printZ();     
63     // 错误，基类的私有成员，私有继承后做为派生类的私有成员，不能外部访问
64　　 a.show();
65    return 0;
66 }

总结：

当类的继承方式为私有继承的时候，基类的public和protected成员被继承后做为派生类的私有成员。在类的外部经过派生类的对象没法访问，但在派生类的内部是能够直接访问的。基类的private成员在派生类的内部是不能直接访问的，在派生类的外部一样也是不能访问的。若是你想访问的话，能够经过基类提供的public成员函数间接访问。

ii. 公有继承的访问规则

基类成员	Private成员	Public成员	Protected成员
内部访问	不可访问	能够访问	能够访问
对象访问	不可访问	能够访问	不可访问

首先，咱们根据一个具体的例子来看一下。

 1 //基类
 2 class Base
 3 {
 4 public:
 5     Base(int a, int b, int c): x(a),y(b),z(c)
 6     {}
 7     virtual ~Base(void);
 8 
 9     int x;
10     void printX()
11     {
12        printZ();     // 间接的访问基类的private成员
13        printf("X = %d\n", x);
14     }
15 
16 protected:
17     int y;
18     void printY()
19     {
20        printf("Y = %d\n", y);
21     }
22 
23 private:
24     int z;
25     void printZ()
26     {
27        printf("Z = %d\n", z);
28     }
29 };
30 
31 //派生类
32 #include "base.h"
33 
34 class Derivel :
35     public Base
36 {
37 public:
38     Derivel(int a, int b, int c):Base(a,b,c)
39     {}
40     virtual ~Derivel(void);
41 
42     void show()
43     {
44        printX();     // 正确，基类的公有成员，派生类内部访问可能
45        printY();     // 正确，基类的保护成员，派生类内部访问可能
46        printZ();     // 错误，基类的私有成员，派生类不能内部访问
47     }
48 };
49 
50 // main
51 #include "Base.h"
52 #include "Derivel.h"
53 
54 int _tmain(int argc, _TCHAR* argv[])
55 {
56     Derivel a(1,2,3);
57 　　a.printX();     
58 // 正确，基类的公有成员，公有继承后做为派生类的公有成员，能够外部访问
59 　　a.printY();     
60 // 错误，基类的保护成员，公有继承后做为派生类的保护成员，不能外部访问
61 　　a.printZ();     
62 // 错误，基类的私有成员，公有继承后做为派生类的私有成员，不能外部访问
63    a.show();
64    return 0;
65 }

总结：

当类的继承方式为公有继承的时候，基类的public成员被继承后做为派生类的公有成员。在类的外部经过派生类的对象和派生类的内部均可以直接访问。基类的protected成员被继承后做为派生类的保护成员，在类的外部经过派生类的对象不能访问，只能在派生类的内部访问。基类的private成员被继承后做为派生类的私有成员，在派生类的内部是不能直接访问的，在派生类的外部一样也是不能访问的。

iii. 保护继承的访问规则

基类成员	Private成员	Public成员	Protected成员
内部访问	不可访问	能够访问	能够访问
对象访问	不可访问	不可访问	不可访问

首先，咱们根据一个具体的例子来看一下。

 1 // 基类  2 class Base  3 {  4 public:  5 Base(int a, int b, int c): x(a),y(b),z(c)  6  {}  7 virtual ~Base(void);  8  9 int x; 10 void printX() 11  { 12 printZ(); // 间接的访问基类的private成员 13 printf("X = %d\n", x); 14  } 15 16 protected: 17 int y; 18 void printY() 19  { 20 printf("Y = %d\n", y); 21  } 22 23 private: 24 int z; 25 void printZ() 26  { 27 printf("Z = %d\n", z); 28  } 29 }; 30 31 // 派生类 32 #include "base.h" 33 34 class Derivel : 35 protected Base 36 { 37 public: 38 Derivel(int a, int b, int c):Base(a,b,c) 39  {} 40 virtual ~Derivel(void); 41 42 void show() 43  { 44 printX(); // 正确，基类的公有成员，派生类内部访问可能 45 printY(); // 正确，基类的保护成员，派生类内部访问可能 46 printZ(); // 错误，基类的私有成员，派生类不能内部访问 47  } 48 }; 49 50 // main 51 #include "Base.h" 52 #include "Derivel.h" 53 54 int _tmain(int argc, _TCHAR* argv[]) 55 { 56 Derivel a(1,2,3); 57 　　a.printX(); 58 // 错误，基类的公有成员，保护继承后做为派生类的保护成员，不能外部访问 59 　　a.printY(); 60 // 错误，基类的保护成员，保护继承后做为派生类的保护成员，不能外部访问 61 　　a.printZ(); 62 // 错误，基类的私有成员，保护继承后做为派生类的私有成员，不能外部访问 63 　　a.show(); 64 return 0; 65 }

总结：

当类的继承方式为保护继承的时候，基类的public成员被继承后做为派生类的保护成员。在类的外部经过派生类的对象不能访问，在派生类的内部能够直接访问。基类的protected成员被继承后做为派生类的保护成员，在类的外部经过派生类的对象不能访问，只能在派生类的内部访问。基类的private成员被继承后做为派生类的私有成员，在派生类的内部是不能直接访问的，在派生类的外部一样也是不能访问的。