文章目录
之前继承的博客（久到一个月之前的博客）我说到继承的默认成员函数，那么接下来我们进行继承最后三个部分
继承和友元
友元关系不能继承，就是基类的友元不能访问子类私有和保护
用代码更加直观了解：
cpp
#include <iostream>
#include <string>
using namespace std;
class B;
class A
{
public:
friend void Display(const A& a,const B& b);
protected:
string _name;
};
class B :public A{
protected:
int _b;
};
void Display(const A& a, const B& b)
{
cout << a._name << endl;
cout << b._b << endl;
}
int main()
{
A a;
B b;
Display(a,b);
return 0;
}这里就会出现上面说的问题：
这是因为Display函数被声明是A类的友元，所以Display只能访问A类的成员（包括A类中的私有和保护）但是不能访问B类中的私有和保护成员，即使B类是A类的子类。
就好比我有一个工具箱（类 A），里面有一些工具（保护成员 _name）。之后我有一个好朋友（友元函数 Display），我让他使用这些工具。但是，我又制作了一个新的工具箱（类 B），它虽然基于原来的工具箱，但是增加了一些新的工具（成员 _b）。尽管我的朋友可以访问原始工具箱中的工具，但是他不能自动访问新工具箱中的新工具，因为他只被允许使用原始工具箱中的工具。
那么我们如果要Display也能够访问B类可以把Display再B类也声明下友元就可以：
cpp
#include <iostream>
#include <string>
using namespace std;
class B;
class A
{
public:
friend void Display(const A& a,const B& b);
protected:
string _name;
};
class B :public A{
public:
friend void Display(const A& a, const B& b);
protected:
int _b;
};
void Display(const A& a, const B& b)
{
cout << a._name << endl;
cout << b._b << endl;
}
int main()
{
A a;
B b;
Display(a,b);
return 0;
}
这样就没问题了
继承与静态成员
继承和静态成员是两个不同的概念，但它们可以在类的设计中一起使用。
继承 ：是一种机制，允许我们创建一个新的类（派生类），它基于一个已存在的类（基类）。派生类继承了基类的属性和方法，并且可以添加新的属性和方法或者修改继承来的行为。
静态成员 ：是属于类而不是类的实例的成员。无论创建了多少个类的实例，静态成员只有一个副本。静态成员可以通过类名直接访问，不需要创建类的实例。
当继承和静态成员一起使用时，静态成员在基类和派生类之间是共享的。这意味着，如果基类有一个静态成员，派生类会继承这个成员，并且派生类的所有实例都会共享这个静态成员。
下面是一个简单的例子，展示了如何在继承中使用静态成员：
cpp
#include <iostream>
using namespace std;
class Base {
public:
static int staticVar; // 基类的静态成员
};
int Base::staticVar = 10; // 静态成员的定义和初始化
class Derived : public Base {
};
int main() {
Derived d;
cout << "Static variable in Base class: " << Base::staticVar << endl;
cout << "Static variable in Derived class: " << Derived::staticVar << endl;
return 0;
}在这个例子中，Base 类有一个静态成员 staticVar。Derived 类继承了 Base 类，因此它也继承了 staticVar。在 main 函数中，我们创建了一个 Derived 类的实例 d，并通过类名直接访问了静态成员。输出将显示基类和派生类中静态变量的值是相同的，因为它们实际上是同一个变量。
需要注意的是，虽然派生类继承了基类的静态成员，但是静态成员的访问权限仍然遵循继承的访问修饰符。如果基类的静态成员是私有的，那么它不会被派生类继承，也无法在派生类中直接访问。如果静态成员是公有或保护的，它将在派生类中保持相同的访问级别。
复杂的菱形继承及菱形虚拟继承
单继承：
一个子类只有一个父类
多继承：
一个子类有两个或以上直接父类时称这个继承关系为多继承
而在多继承中就会出现菱形继承
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。
这种继承结构可能导致一个问题，即基类中的成员在派生类中存在两份副本，这被称为"歧义继承"。
为了解决这个问题，C++提供了虚继承（virtual inheritance），它允许在菱形继承结构中共享基类的一个单一副本。
下面是一个菱形继承和虚继承的例子：
cpp
#include <iostream>
using namespace std;
// 基类
class Base {
public:
int value;
};
// 第一个中间类，虚继承自Base
class IntermediateA : virtual public Base {
};
// 第二个中间类，虚继承自Base
class IntermediateB : virtual public Base {
};
// 派生类，继承自两个中间类
class Derived : public IntermediateA, public IntermediateB {
};
int main() {
Derived d;
d.value = 10; // 不存在歧义，因为Base被虚继承
cout << "Value: " << d.value << endl;
return 0;
}在这个例子中，IntermediateA 和 IntermediateB 都虚继承自 Base 类，然后 Derived 类继承自 IntermediateA 和 IntermediateB。由于使用了虚继承，Derived 类中只有一个 Base 类的副本，因此 d.value 的访问没有歧义。
如果没有使用虚继承，而是直接继承，那么 Derived 类将包含两个 Base 类的副本，导致访问 value 时出现歧义，不知道应该使用哪一个副本。
虚继承通过在派生类中创建一个共享的基类子对象来解决歧义问题，这个子对象被称为虚基类子对象。这样，无论派生类有多少途径继承自基类，都只有一个基类子对象被创建，从而避免了多重继承中的歧义问题。
总结
- 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱
形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设
计出菱形继承。否则在复杂度及性能上都有问题。 - 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。
- 继承和组合
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
优先使用对象组合，而不是类继承 。
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称
为白箱复用(white-box reuse)。术语"白箱"是相对可视性而言：在继承方式中，基类的
内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很
大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象
来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复
用(black-box reuse)，因为对象的内部细节是不可见的。对象只以"黑箱"的形式出现。
组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被
封装。
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有
些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用
继承，可以用组合，就用组合。
单个赞蟹蟹