==继承==下半部分机制详解[ C++ ]

之前继承的博客（久到一个月之前的博客）我说到继承的默认成员函数，那么接下来我们进行继承最后三个部分

继承和友元

友元关系不能继承，就是基类的友元不能访问子类私有和保护
用代码更加直观了解：

#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类也声明下友元就可以：

#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;
}

这样就没问题了

继承与静态成员

继承和静态成员是两个不同的概念，但它们可以在类的设计中一起使用。
继承：是一种机制，允许我们创建一个新的类（派生类），它基于一个已存在的类（基类）。派生类继承了基类的属性和方法，并且可以添加新的属性和方法或者修改继承来的行为。
静态成员：是属于类而不是类的实例的成员。无论创建了多少个类的实例，静态成员只有一个副本。静态成员可以通过类名直接访问，不需要创建类的实例。
当继承和静态成员一起使用时，静态成员在基类和派生类之间是共享的。这意味着，如果基类有一个静态成员，派生类会继承这个成员，并且派生类的所有实例都会共享这个静态成员。
下面是一个简单的例子，展示了如何在继承中使用静态成员：

#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），它允许在菱形继承结构中共享基类的一个单一副本。
下面是一个菱形继承和虚继承的例子：

#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 时出现歧义，不知道应该使用哪一个副本。
虚继承通过在派生类中创建一个共享的基类子对象来解决歧义问题，这个子对象被称为虚基类子对象。这样，无论派生类有多少途径继承自基类，都只有一个基类子对象被创建，从而避免了多重继承中的歧义问题。

总结

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱
   形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设
   计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。
3. 继承和组合
   public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
   组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
   优先使用对象组合，而不是类继承 。
   继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称
   为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的
   内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很
   大的影响。派生类和基类间的依赖关系很强，耦合度高。
   对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象
   来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复
   用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。
   组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被
   封装。
   实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有
   些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用
   继承，可以用组合，就用组合。
   
   单个赞蟹蟹