之前继承的博客(久到一个月之前的博客)我说到继承的默认成员函数,那么接下来我们进行继承最后三个部分
![](https://i-blog.csdnimg.cn/direct/cfb743cdc7384804897b652cd74cbc77.png)
继承和友元
友元关系不能继承,就是基类的友元不能访问子类私有和保护
用代码更加直观了解:
#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
)。尽管我的朋友可以访问原始工具箱中的工具,但是他不能自动访问新工具箱中的新工具,因为他只被允许使用原始工具箱中的工具。
![](https://i-blog.csdnimg.cn/direct/b1a010a6e3794888aa2f0775228bd901.gif)
那么我们如果要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;
}
这样就没问题了
![](https://i-blog.csdnimg.cn/direct/464d2987ec5f4fe2b4851979a1353346.gif)
继承与静态成员
继承和静态成员是两个不同的概念,但它们可以在类的设计中一起使用。
继承:是一种机制,允许我们创建一个新的类(派生类),它基于一个已存在的类(基类)。派生类继承了基类的属性和方法,并且可以添加新的属性和方法或者修改继承来的行为。
静态成员:是属于类而不是类的实例的成员。无论创建了多少个类的实例,静态成员只有一个副本。静态成员可以通过类名直接访问,不需要创建类的实例。
当继承和静态成员一起使用时,静态成员在基类和派生类之间是共享的。这意味着,如果基类有一个静态成员,派生类会继承这个成员,并且派生类的所有实例都会共享这个静态成员。
下面是一个简单的例子,展示了如何在继承中使用静态成员:
#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
时出现歧义,不知道应该使用哪一个副本。
虚继承通过在派生类中创建一个共享的基类子对象来解决歧义问题,这个子对象被称为虚基类子对象。这样,无论派生类有多少途径继承自基类,都只有一个基类子对象被创建,从而避免了多重继承中的歧义问题。
总结
- 很多人说C++语法复杂,其实多继承就是一个体现。有了多继承,就存在菱形继承,有了菱
形继承就有菱形虚拟继承,底层实现就很复杂。所以一般不建议设计出多继承,一定不要设
计出菱形继承。否则在复杂度及性能上都有问题。 - 多继承可以认为是C++的缺陷之一,很多后来的OO语言都没有多继承,如Java。
- 继承和组合
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A,每个B对象中都有一个A对象。
优先使用对象组合,而不是类继承 。
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称
为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言:在继承方式中,基类的
内部细节对子类可见 。继承一定程度破坏了基类的封装,基类的改变,对派生类有很
大的影响。派生类和基类间的依赖关系很强,耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象
来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复
用(black-box reuse),因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。
组合类之间没有很强的依赖关系,耦合度低。优先使用对象组合有助于你保持每个类被
封装。
实际尽量多去用组合。组合的耦合度低,代码维护性好。不过继承也有用武之地的,有
些关系就适合继承那就用继承,另外要实现多态,也必须要继承。类之间的关系可以用
继承,可以用组合,就用组合。
单个赞蟹蟹