目录
5、继承与友元
6、继承与静态成员
7、复杂的菱形继承和菱形虚拟继承
8、继承的总结与反思
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; // 此时这一行会报错
}同样，子类的友元也不能访问父类的私有或保护的成员
class Student;
class Person
{
public:
// friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
};
class Student : public Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
cout << p._name << endl; // 此时这一行会报错
cout << s._stuNum << endl;
}6、继承与静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。能被继承，但是只要一个static成员
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 TestPerson()
{
Person p1;
Student st1;
Student st2;
cout << &p1._count << endl;
cout << &st1._count << endl;
cout << &st2._count << endl;
}
int main()
{
TestPerson();
return 0;
}结果是
7、复杂的菱形继承和菱形虚拟继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
菱形继承：菱形继承是多继承的一种特殊情况
就类似于蔬菜和水果都属于植物，并且西红柿既属于蔬菜也属于水果，所以西红柿里面有两份植物，就会造成数据的冗余和二义性
class Person
{
public:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _num; //学号
};
class Teacher : public Person
{
protected:
int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。所以当Assistant对象直接访问_name会报错，因为不知道访问的是从哪一个父类中继承下来的_name，所以必须指定类域
void Test()
{
// 这样会有二义性无法明确知道访问的是哪一个
Assistant a;
a._name = "peter"; // 这一句会报错
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}
虽然指定类域可以，但是仍然无法解决数据冗余的问题
在C++中引入了虚拟继承来解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用
class Person
{
public:
string _name; // 姓名
};
class Student : virtual public Person
{
protected:
int _num; //学号
};
class Teacher : virtual public Person
{
protected:
int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};这样就可以正常对Assistant对象中的_name赋值了
void Test()
{
Assistant a;
a._name = "peter";
}
当然，也可以指定类域，但是修改了一个类中的_name，其他的_name也都会跟着变
实际上是将基类的_name放在Assistant对象的最下面，Assistant的父类Student和Teacher中只存放_name的地址，所以Assistant对象中只有一个_name
注意，不是一定要是标准菱形才是菱形继承，像上面这样的也是菱形继承，并且virtual加在B、C上，谁会造成冗余，在第一时间继承它时就要加(B中有一份A，C中也有一份A，所以A就会产生数据冗余)
实际中，并不建议使用菱形继承，可以使用多继承
IO流就是一个标准的菱形继承
8、继承的总结与反思
1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承，如Java
3. 继承和组合
首先来介绍一下什么是组合。组合就是一个类中定义了其他类的成员变量，相比于继承，可以定义多个。组合和继承的本质都是复用
class Tire {
protected:
string _brand = "Michelin"; // 品牌
size_t _size = 17; // 尺寸
};
class Car {
protected:
string _colour = "白色"; // 颜色
string _num = "陕ABIT00"; // 车牌号
Tire _t1; // 轮胎
Tire _t2; // 轮胎
Tire _t3; // 轮胎
Tire _t4; // 轮胎
};这就是一个组合
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。像植物和水果，水果就是一种植物，所以是is-a的关系
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。不能说车是一个轮胎，应该说车有轮胎，所以是has-a的关系
当然，也可以is-a和has-a同时拥有。如list和queue，可以说队列是一个特殊的链表，即is-a，也可以说队列里有一个链表，即has-a
什么时候使用对象组合，什么时候使用继承呢？当关系是is-a就使用继承，当关系是has-a就使用组合，当两种关系都可以时，优先使用组合
为什么组合相对于继承会更好呢？
首先，我们来了解几个专业术语
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合
