C++私有继承与EBO深入分析讲解

Hello！大家好呀，近期逗比老师的一个学生问了我这样一个问题：“C++里的私有继承到底有什么意义？”

不知道你有没有跟他一样的困惑。的确，我们在编写C++项目中，几乎是没有用过私有继承（这里包括protected继承和private继承），都是清一色的public继承。有的老师干脆直接告诉学生，你见到继承就是public，其他那俩是历史原因，当它不存在就好了。

这种说法呢，其实也有一定道理，但也不全对。对的部分在于：C++中，确实只有public继承才表示的OOP理论中的“继承”，而私有继承其实对应的是OOP理论中的“组合”关系，所以说“见到继承就写public”这话其实没毛病。然而不对的部分在于：私有继承是为了解决某些性能问题而存在的，我们知道通常表示组合的做法是成员对象，但在某些极端情况下，成员对象会出现一些性能问题，这时我们不得不用私有继承来代替。

私有继承本质不是继承

在此强调，这个标题中，第一个“继承”指的是一种C++语法，也就是class A : B {};这种写法。而第二个“继承”指的是OOP（面向对象编程）的理论，也就是A is a B的抽象关系，类似于“狗”继承自“动物”的这种关系。

所以我们说，私有继承本质是表示组合的，而不是继承关系，要验证这个说法，只需要做一个小实验即可。我们知道最能体现继承关系的应该就是多态了，如果父类指针能够指向子类对象，那么即可实现多态效应。

请看下面的例程：

class Base {};
class A : public Base {};
class B : private Base {};
class C : protected Base {};
void Demo() {
  A a;
  B b;
  C c;
  Base *p = &a; // OK
  p = &b; // ERR
  p = &c; // ERR
}

这里我们给Base类分别编写了A、B、C三个子类，分别是public、private个protected继承。然后用Base *类型的指针去分别指向a、b、c。发现只有public继承的a对象可以用p直接指向，而b和c都会报这样的错：

Cannot cast 'B' to its private base class 'Base'
Cannot cast 'C' to its protected base class 'Base'

也就是说，私有继承是不支持多态的，那么也就印证了，他并不是OOP理论中的“继承关系”，但是，由于私有继承会继承成员变量，也就是可以通过b和c去使用a的成员，那么其实这是一种组合关系。或者，大家可以理解为，把b.a.member改写成了b.A::member而已。

那么私有继承既然是用来表示组合关系的，那我们为什么不直接用成员对象呢？为什么要使用私有继承？这是因为用成员对象在某种情况下是有缺陷的。

空类大小

在解释私有继承的意义之前，我们先来看一个问题，请看下面例程

class T {};
// sizeof(T) = ?

T是一个空类，里面什么都没有，那么这时T的大小是多少？有的同学可能不假思索就会回答0。照理说，空类的大小就是应该是0，但如果真的设置为0的话，会有很严重的副作用，请看例程：

class T {};
void Demo() {
  T arr[10];
  sizeof(arr); // 0
  T *p = arr + 5;
  // 此时p==arr
  p++; // ++其实无效
}

发现了吗？假如T的大小是0，那么T指针的偏移量就永远是0，T类型的数组大小也将是0，而如果它成为了一个成员的话，问题会更严重：

struct Test {
  T t;
  int a;
};
// t和a首地址相同

由于T是0大小，那么此时Test结构体中，t和a就会在同一首地址。

所以，为了避免这种0长的问题，编译器会针对于空类自动补一个字节的大小，也就是说其实sizeof(T)是1，而不是0。

这里需要注意的是，不仅是绝对的空类会有这样的问题，只要是不含有非静态成员变量的类都有同样的问题，例如下面例程中的几个类都可以认为是空类：

class A {};
class B {
  static int m1;
  static int f();
};
class C {
public:
  C();
  ~C();
  void f1();
  double f2(int arg) const;
};

有了自动补1字节，T的长度变成了1，那么T*的偏移量也会变成1，就不会出现0长的问题。但是，这么做就会引入另一个问题，请看例程：

class Empty {};
class Test {
  Empty m1;
  long m2;
};
// sizeof(Test)==16

由于Empty是空类，编译器补了1字节，所以此时m1是1字节，而m2是8字节，m1之后要进行字节对齐，因此Test变成了16字节。如果Test中出现了很多空类成员，这种问题就会被继续放大。

这就是用成员对象来表示组合关系时，可能会出现的问题，而私有继承就是为了解决这个问题的。

空基类成员压缩

（EBO，Empty Base Class Optimization）

在上一节最后的历程中，为了让m1不再占用空间，但又能让Test中继承Empty类的其他内容（例如函数、类型重定义等），我们考虑将其改为继承来实现，EBO就是说，当父类为空类的时候，子类中不会再去分配父类的空间，也就是说这种情况下编译器不会再去补那1字节了，节省了空间。

但如果使用public继承会怎么样？

class Empty {};
class Test : public Empty {
  long m2;
};
// 假如这里有一个函数让传Empty类对象
void f(const Empty &obj) {}
// 那么下面的调用将会合法
void Demo() {
  Test t;
  f(t); // OK
}

Test由于是Empty的子类，所以会触发多态性，t会当做Empty类型传入f中。这显然问题很大呀！如果用这个例子看不出问题的话，我们换一个例子：

class Alloc {
public:
  void *Create();
  void Destroy();
};
class Vector : public Alloc {
};
// 这个函数用来创建buffer
void CreateBuffer(const Alloc &alloc) {
  void *buffer = alloc.Create(); // 调用分配器的Create方法创建空间
}
void Demo() {
  Vector ve; // 这是一个容器
  CreateBuffer(ve); // 语法上是可以通过的，但是显然不合理
}

内存分配器往往就是个空类，因为它只提供一些方法，不提供具体成员。Vector是一个容器，如果这里用public继承，那么容器将成为分配器的一种，然后调用CreateBuffer的时候可以传一个容器进去，这显然很不合理呀！

那么此时，用私有继承就可以完美解决这个问题了

class Alloc {
public:
  void *Create();
  void Destroy();
};
class Vector : private Alloc {
private:
  void *buffer;
  size_t size;
  // ...
};
// 这个函数用来创建buffer
void CreateBuffer(const Alloc &alloc) {
  void *buffer = alloc.Create(); // 调用分配器的Create方法创建空间
}
void Demo() {
  Vector ve; // 这是一个容器
  CreateBuffer(ve); // ERR，会报错，私有继承关系不可触发多态
}

此时，由于私有继承不可触发多态，那么Vector就并不是Alloc的一种，也就是说，从OOP理论上来说，他们并不是继承关系。而由于有了私有继承，在Vector中可以调用Alloc里的方法以及类型重命名，所以这其实是一种组合关系。

而又因为EBO，所以也不用担心Alloc占用Vector的成员空间的问题。

总结

总结下来，私有继承其实是表示组合关系的，它是当组合类为空类时，为了增强性能而提供的一种成员对象的代替方案。

好啦！相信大家已经明白私有继承的存在意义了，这里建议大家阅读一下STL源码，会看到绝大多数容器和分配器之间都是使用私有继承方式的。如果还有什么疑问欢迎评论区抛出！

到此这篇关于C++私有继承与EBO深入分析讲解的文章就介绍到这了,更多相关C++私有继承 内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论