C++私有继承与EBO实例分析

这篇文章主要介绍“C++私有继承与EBO实例分析”，在日常操作中，相信很多人在C++私有继承与EBO实例分析问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”C++私有继承与EBO实例分析”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

私有继承本质不是继承

在此强调，这个标题中，第一个“继承”指的是一种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的成员空间的问题。

到此，关于“C++私有继承与EBO实例分析”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注亿速云网站，小编会继续努力为大家带来更多实用的文章！