【C++】继承（下）

5. 继承与友元

对于友元关系，类继承的时候是不能被继承的，也就是说，基类友元不能访问派生类的私有和保护成员，如果需要访问的话，就需要在派生类中也规定友元。

class Student;
class Person
{
public:
  friend void Display(const Person& p, const Student& s);
protected:
  string _name; // 姓名
};
class Student : public Person
{
protected:
  int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
  cout << p._name << endl;
  cout << s._stuNum << endl;
}
void Test6()
{
  Person p;
  Student s;
  Display(p, s);
}

解决方案：

6. 继承与静态成员

在基类中定义了一个静态成员，则此成员在继承体系中是共享的，只有一个这样的成员

class Person
{
public:
  Person() { ++_count; }
protected:
  string _name; // 姓名
public:
  static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
  int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
string _seminarCourse; // 研究科目
};
void Test7()
{
  Student s1;
  Student s2;
  Student s3;
  Graduate s4;
  cout << "人数:" << Person::_count << endl;
  Student::_count = 0;
  cout << "人数:" << Person::_count << endl;
}

7. 菱形继承与菱形虚拟继承

1. 继承的种类

在C++继承的设计中，为了满足各种实际情况，设计了单继承和多继承

单继承：一个子类只有一个直接父类

多继承：一个子类有超过一个父类

在上述情况的前提下，会出现一种可能的继承结构：菱形继承

在菱形继承中就会出现数据冗余和二义性的问题。对于上述的例子，在Assistant对象中Person的成员会有两份，造成了数据冗余，如果在Assistant对象中访问Person中的成员就会出现二义性，不知道访问Student基类还是Teacher基类中的Person成员。虽然我们可以使用显示指定访问类的方法解决二义性的问题，但是对于数据冗余还是没有办法解决，所以这里引入了虚拟继承的方式

2. 虚拟继承

对于上面的继承关系，在Student和Teacher的继承中使用Person虚拟继承，就可以解决问题，但是这里注意虚拟继承不要在其他地方使用

class Person
{
public:
  string _name; // 姓名
};
//class Student : public Person
class Student : virtual public Person//虚拟继承
{
protected:
  int _num; //学号
};
//class Teacher : public Person
class Teacher : virtual public Person//虚拟继承
{
protected:
  int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
  string _majorCourse; // 主修课程
};

虚拟继承解决数据冗余和二义性的原理

首先，这里我们给出一个简化的菱形继承的示例

class A
{
public:
  int _a;
};
// class B : public A
class B : virtual public A
{
public:
  int _b;
};
// class C : public A
class C : virtual public A
{
public:
  int _c;
};
class D : public B, public C
{
public:
  int _d;
};
void Test8()
{
  D d;
  d.B::_a = 1;
  d.C::_a = 2;
  d._b = 3;
  d._c = 4;
  d._d = 5;
}

如果不适用虚拟继承的方式，那么对象d的内容是这样的

当使用虚拟继承之后,d对象的内容是这样的：

可以看到，这里是把公共的_a放到了最下面，这个_a同时属于B和C，那么他们怎么找到_a呢？这里是通过B和C的两个指针，指向的一张虚基表，着两个指针叫做虚基表指针，虚基表指针中存放的是偏移量，通过偏移量就可以找到下面的_a。

对上述的结构，有下面一张图来辅助理解：

8. 继承与组合

继承的本质就是类的复用，类的复用除了继承之外，还有一种复用方式叫组合，二者最大的区别就是访问方式不同

• public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
• 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象

class M
{
};
class N : public M//public继承
{
};
class X//组合
{
public:
  M mm;
};

继承实际上是一种白箱复用，组合是一种黑箱复用，继承中派生类对于基类的内部细节大多可见，一定程度上破坏了封装，而组合就不会关心内部实现，只是通过提供的接口来使用，高内聚，低耦合，有很好的封装性。当然，由于组合使用的特性，对被组合类的接口要求就相对高一点。

综上，这里有一个原则：优先使用对象组合，而不是继承。

9.总结

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。

2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。

3. 在继承和组合中，优先使用组合优先使用对象组合，而不是类继承。