C/C++--私有继承

一、私有继承有什么作用

[cpp] view plain copy

1. <span style="font-size:18px;">#include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Person  
6. {  
7. public:  
8.     void eat()  { cout<<"Person eat"<<endl; }  
9. };  
10.   
11. class Student : private Person      //私有继承  
12. {  
13. public:  
14.     void study() { cout << "Student Study"<<endl; }  
15. };  
16.   
17. int main()  
18. {  
19.     Person p;  
20.     Student s;  
21.       
22.     p.eat();  
23.     s.study();  
24.     s.eat();            //编译错误  
25.     p = s;              //编译错误  
26.       
27.     return 0;  
28. }</span>  

　　此程序的两个编译错误分别说明了私有继承的规则。

　　第一个规则，和公有继承相反，如果两个类之间的继承关系为私有，编译器一般不会讲派生类对象转换成基类对象。这就是25行出现的错误。

　　第二个规则，从私有基类继承而来的成员都成为了派生类的私有成员——即使它们在基类中是保护或公有成员。这是第24行出现的错误。

　　可以看出，私有继承时派生类与基类不是“is a”的关系，而是意为着“Is-Implement-In-Term-Of”（以...实现）。如果使类D私有继承于类B，这样做是因为你想利用类B中已经存在的代码，而不是因为类B的对象和类D的对象之间有什么概念上的关系。因此，私有继承在软件设计过程中毫无意义，只是在软件实现时才有用。

二、私有继承和组合有什么相同点和不同点

私有继承和组合有什么相同点和不同点？该如何选择？

解析：

　　使用组合表示“有一个（Has-A）”的关系。如果在组合中需要使用一个对象的某些方法，则完全可以利用私有继承代替。

　　私有继承下派生类会获得基类的一份备份，同时得到了访问基类的公共以及保护接口的权利和重写基类虚函数的能力。它意味着“以...实现”，它是组合的一种语法上的变形（聚合或者“有一个”）。

例如：“汽车有一个引擎”关系可以用单一组合表示，也可以用私有继承表示：

[cpp] view plain copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class Engine  
6. {  
7.     int numCylinders;  
8. public:  
9.     Engine(int num) : numCylinders(num) {}  //Engine构造函数  
10.     void start()  
11.     {  
12.         cout<<"Engine start, "<<numCylinders<<" Cylinders"<<endl;  
13.     }  
14. };  
15.   
16. class Car_pri : private Engine              //私有继承  
17. {  
18. public:  
19.     Car_pri():Engine(8) {}                  //调用基类的构造函数  
20.     void start()  
21.     {  
22.         Engine::start();  
23.     }  
24. };  
25.   
26. class Car_comp  
27. {  
28.     Engine engine;                          //组合Engine对象  
29. public:  
30.     Car_comp() : engine(8) { }              //给成员engine初始化  
31.     void start()  
32.     {  
33.         engine.start();  
34.     }  
35. };  
36.   
37. int main()  
38. {  
39.     Car_pri car_pri;  
40.     Car_comp car_comp;  
41.     car_pri.start();  
42.     car_comp.start();  
43.       
44.     return 0;  
45. }  

　　由此看出，“有一个”关系既可以用私有继承表示，也可以用单一组合表示。

　　类Car_pri和Car_comp有很多相似点：

（1）它们都只有一个Engine被确切的包含于Car中。

（2）它们都不能进行指针转换，如将Car_pri*转换为Engine*。

（3）它们都有一个start方法，并且都包含在Engine对象中调用start方法。

　　也有下面一些区别：

（1）如果想让每个Car都包含若干Engine，那么只能用单一组合的形式。

（2）私有继承形式可能引入不必要的多重继承。

（3）私有继承形式允许Car的成员将Car*转换为Engine*。

（4）私有继承形式允许访问基类的保护成员。

（5）私有继承形式允许Car重写Engine的虚函数。

组合和私有继承之间如何选择呢？这里有个原则：尽可能使用组合，万不得已才使用私有继承