Effective C++ 读书笔记 Item39 明智而审慎地使用 private 继承

朱雀 2020-07-05 04:53 753阅读 0赞

Item 32提出public继承表示"is-a"的关系，这是因为编译器会在需要的时候将子类对象隐式转换为父类对象。 然而private继承则不然：

class Person { ... };
    class Student: private Person { ... };     // inheritance is now private
    void eat(const Person& p);                 // anyone can eat
     
    Person p;                                  // p is a Person
    Student s;                                 // s is a Student
    eat(p);                                    // fine, p is a Person
    eat(s);                                    // error! a Student isn't a Person

`Person`可以`eat`，但`Student`却不能`eat`。这是private继承和public继承的不同之处：

*  编译器不会把子类对象转换为父类对象
 *  父类成员（即使是public、protected）都变成了private

子类继承了父类的实现，而没有继承任何接口（因为public成员都变成private了）。 因此private继承是软件实现中的概念，与软件设计无关。 private继承和对象组合类似，都可以表示"is-implemented-in-terms-with"的关系。那么它们有什么区别呢？ 在面向对象设计中，对象组合往往比继承提供更大的灵活性，只要可以使用对象组合就不要用private继承。

# private继承 #

我们的`Widget`类需要执行周期性任务，于是希望继承`Timer`的实现。 因为`Widget`不是一个`Timer`，所以我们选择了private继承：

class Timer {
    public:
       explicit Timer(int tickFrequency);
       virtual void onTick() const;          // automatically called for each tick
    };
    class Widget: private Timer {
    private:
      virtual void onTick() const;           // look at Widget usage data, etc.
    };

private继承的实现非常简单，而且有时只能使用private继承：

1.  当Widget需要访问Timer的protected成员时。因为对象组合后只能访问public成员，而private继承后可以访问protected成员。
2.  当Widget需要重写Timer的虚函数时。比如上面的例子中，由于需要重写onTick单纯的对象组合是做不到的。

# 对象组合 #

我们知道对象组合也可以表达"is-implemented-in-terms-of"的关系， 上面的需求当然也可以使用对象组合的方式实现。但由于需要重写（override）`Timer`的虚函数，所以还是需要一个继承关系的：

class Widget {
    private:
        class WidgetTimer: public Timer {
        public:
            virtual void onTick() const;
        };
        WidgetTimer timer;
    };

内部类WidgetTimer public继承自Timer，然后在Widget中保存一个WidgetTimer对象。 这是public继承+对象组合的方式，比private继承略为复杂。但对象组合仍然拥有它的好处：

1.  你可能希望禁止Widget的子类重定义onTick。在Java中可以使用finel关键字，在C\#中可以使用sealed。 在C++中虽然没有这些关键字，但你可以使用public继承+对象组合的方式来做到这一点。上述例子便是。
2.  减小Widget和Timer的编译依赖。如果是private继承，在定义Widget的文件中势必需要引入\#include"timer.h"。 但如果采用对象组合的方式，你可以把WidgetTimer放到另一个文件中，在Widget中保存WidgetTimer的指针并声明WidgetTimer即可， 见Item 31。

# EBO特性 #

我们讲虽然对象组合优于private继承，但有些特殊情况下仍然可以选择private继承。 需要EBO（empty base optimization）的场景便是另一个特例。 由于技术原因，C++中的独立空对象也必须拥有非零的大小，请看：

class Empty {}; 
    class HoldsAnInt {
    private:
      int x;
      Empty e;        
    };

Empty e是一个空对象，但你会发现sizeof(HoldsAnInt) > sizeof(int)。 因为C++中独立空对象必须有非零大小，所以编译器会在Empty里面插入一个char，这样Empty大小就是1。 由于字节对齐的原因，在多数编译器中HoldsAnInt的大小通常为2\*sizeof(int)。更多字节对齐和空对象大小的讨论见Item 7。 但如果你继承了Empty，情况便会不同：

class HoldsAnInt: private Empty {
    private:
      int x;
    };

这时sizeof(HoldsAnInt) == sizeof(int)，这就是空基类优化（empty base optimization，EBO）。 当你需要EBO来减小对象大小时，可以使用private继承的方式。

继承一个空对象有什么用呢？虽然空对象不可以有非静态成员，但它可以包含typedef, enum, 静态成员，非虚函数 （因为虚函数的存在会导致一个徐函数指针，它将不再是空对象）。 STL就定义了很多有用的空对象，比如unary\_function, binary\_function等。

# 总结 #

*  private继承的语义是"is-implemented-in-terms-of"，通常不如对象组合。但有时却是有用的：比如方法protected成员、重写虚函数。
 *  不同于对象组合，private继承可以应用EBO，库的开发者可以用它来减小对象大小。