今天同事聊起C++的非公有继承，发现自己知识又有些模糊了。晚上回来Demo温习一下

Basic Rule:公有继承用于接口继承，反映"is-a"关系；非公有继承用于方法继承实现和方法封装性控制。

引CSDN一段关于非公有继承使用情景的说明:

私有继承:

第一个规则：和公有继承相反，如果两个类之间的继承关系为私有，编译器一般不会将派生类对象转换成基类对象。

第二个规则: 从私有基类继承而来的成员都成为了派生类的私有成员，即使它们在基类中是保护或公有成员。私有继承的含义：私有继承意味着 "用...来实现"。如果使类D私有继承于类B，这样做是因为你想利用类B中已经存在的某些代码，而不是因为类型B的对象和类型D的对象之间有什么概念上的关系。因而，私有继承纯粹是一种实现技术。私有继承意味着只是继承实现，接口会被忽略。如果D私有继承于B，就是说D对象在实现中用到了B对象，仅此而已。私有继承在软件 "设计" 过程中毫无意义，只是在软件 "实现" 时才有用。

私有继承控制实现的一个例子:

1. class Uncopyable { 
2. protected:                                   // allow construction 
3.   Uncopyable() {}                            // and destruction of 
4.   ~Uncopyable() {}                           // derived objects... 
5.  
6. private: 
7.   Uncopyable(const Uncopyable&);             // ...but prevent copying 
8.   Uncopyable& operator=(const Uncopyable&); 
9. }; 
10.  
11. class HomeForSale: private Uncopyable {      // class no longer 
12.   ...                                        // declares copy ctor or 
13. };   

上面的禁止Copy/Assignment Constructor当然也可以使用下面方法实现：

1. // A macro to disallow the copy constructor and operator= functions 
2. // This should be used in the private: declarations for a class 
3. #define DISALLOW_COPY_AND_ASSIGN(TypeName) \ 
4.   TypeName(const TypeName&);               \ 
5.   TypeName& operator=(const TypeName&) 
6.  
7. class Foo { 
8.  public: 
9.   Foo(int f); 
10.   ~Foo(); 
11.  
12.  private: 
13.   DISALLOW_COPY_AND_ASSIGN(Foo); 
14. }; 

最后附上一段阳春的Demo Code参考：

ClassDemo.h

1. class ClassDemo 
2. { 
3. public: 
4.     ClassDemo(void); 
5.     ~ClassDemo(void); 
6.  
7.     void Dump(void); 
8.     virtual void VDump(void); 
9.  
10. protected: 
11.     void PDump(void); 
12.  
13. private: 
14.     void PRDump(void); 
15. }; 
16.  
17. class ClassD1 : private ClassDemo 
18. { 
19. public: 
20.     ClassD1(void){} 
21.     ~ClassD1(void){} 
22.     void Dump(void); 
23.     virtual void VDump(void); 
24.  
25. }; 
26.  
27. class ClassD2 : public ClassDemo 
28. { 
29. public: 
30.     ClassD2(void){} 
31.     ~ClassD2(void){} 
32.     void Dump(void); 
33.     virtual void VDump(void); 
34. }; 

ClassDemo.cpp

1. #include <iostream> 
2.  
3. #include "ClassDemo.h" 
4.  
5. ClassDemo::ClassDemo(void) 
6. { 
7. } 
8.  
9. ClassDemo::~ClassDemo(void) 
10. { 
11. } 
12.  
13. void ClassDemo::Dump() 
14. { 
15.     std::cout<<__FUNCTION__<<std::endl; 
16. } 
17.  
18. void ClassDemo::VDump() 
19. { 
20.     std::cout<<__FUNCTION__<<std::endl; 
21. } 
22.  
23. void ClassDemo::PDump() 
24. { 
25.     std::cout<<__FUNCTION__<<std::endl; 
26. } 
27.  
28. void ClassDemo::PRDump() 
29. { 
30.     std::cout<<__FUNCTION__<<std::endl; 
31. } 
32.  
33. void ClassD1::Dump() 
34. { 
35.     //this->PRDump(); //error C2248: cannot access private member 
36.     this->PDump(); 
37.     std::cout<<__FUNCTION__<<std::endl; 
38. } 
39.  
40. void ClassD1::VDump() 
41. { 
42.     std::cout<<__FUNCTION__<<std::endl; 
43. } 
44.  
45. void ClassD2::Dump() 
46. { 
47.     this->PDump(); 
48.     std::cout<<__FUNCTION__<<std::endl; 
49. } 
50.  
51. void ClassD2::VDump() 
52. { 
53.     std::cout<<__FUNCTION__<<std::endl; 
54. } 

main.cpp

1. ClassDemo *p_demo1 = new ClassDemo(); 
2. //ClassDemo *p_demo2 = new ClassD1();//error C2243: 'type cast' 
3. ClassD1 d1; 
4. ClassDemo *p_demo3 = new ClassD2(); 
5.  
6. p_demo1->Dump();//base 
7. p_demo1->VDump();//base 
8. //p_demo2->Dump();//base 
9. //p_demo2->VDump();//D1 
10. d1.Dump(); 
11. d1.VDump(); 
12. p_demo3->Dump();//base 
13. p_demo3->VDump();//D2 
14.  
15. delete p_demo1; 
16. //delete p_demo2; 
17. delete p_demo3; 

Result:

P.S. 抽空该温习一下Effective C++啦，囧