c++_继承

🏷如被何实现一个不能被继承的类（或是继承无意义的类）

将构造函数定义成私有的就行了，即：私有化父类的构造函数
c++ 11 新增关键字final 修饰父类直接不能被继承

class A final
{
	........
}

🏷继承与有元

有元关系不能被继承

🏷继承与静态成员

思考一个问题？静态成员变量可以继承吗？
你会发现在子类中确实可以访问静态成员变量,但是当你打印父类的静态成员变量和子类的静态成员变量的时候你会发现他们的地址是一样的。
我们可以这样来理解：首先静态成员变量它不是属于某一个对象的，它是属于整个类的。所以它这里只是相当继承了使用权,其实这里的静态成员变量的继承和成员函数的继承很像，子类继承父类的成员函数也是继承的使用权,并不是自己在单独去创建一份。

🏷复杂的菱形继承及菱形虚拟继承

📌单继承：一个子类只有一个直接父类时称这个继承关系为单继承

![[Pasted image 20231121171709.png]]

📌多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

📌菱形继承：菱形继承是多继承的一种特殊情况。

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题
在这里插入图片描述

📌怎么分析的？

首先这个Assistant 继承了Student ,同时又继承了Teacher ，Student 里面有成员变量:_age, _name, 等 那Teacher 里面也有成员变量:_age, _name, 等，当你想访问，Assistant时，就有两个_age 两个_name ,编译器不知道你想要的是哪个，所以就存在二义性
而且，就算你能容忍这个问题，但是所有的信息存两份会造成空间的白白浪费。

📌解决方法

为了解决菱形继承的上面两个问题，c++的祖师爷想出了一个新的办法，增加了一个新的关键字：virtual 虚继承

class Person
{
public:
	string _name; // 姓名
};
class Student : virtual public Person  //看在这里加上了 关键字:vitual
{
protected:
	int _num; //学号
};
class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

加上了vitual 之后，就是继承的同一份了，就避免了数据冗余的问题。

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

一下面的代码为列：

#include<iostream>
using namespace std;


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

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

✒如何解决二义性的问题的？

我们可以通过指定类域的方法来避免这个二义性的问题：
b.B::_a = 1
b.C::_a = 2

✒如何解决数据冗余的问题的？

对象d 要存一个来自父类的成员变量_a 为了避免数据冗余，我们就不在B类和c类中存这个成员变量了，我们把_a 单独存一个地方，这样无论你使用b.B::_a = 1 还是b.c::_a = 2访问的都是一个地方，这样数据冗余的问题就解决了。

🏷继承的总结和反思

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱

形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设

计出菱形继承。否则在复杂度及性能上都有问题。

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

🏷继承和组合

📌什么是组合？

class C
{
	int _c;
};

class D
{
protected:
	C _c;
};

上面的代码例子就是组合。
想一想：继承和组合的相同点是什么，不同点是什么？
🔎相同点：
1. 都可以复用（继承的核心是复用：子类复用父类

🔎不同点：

#include<iostream>
using namespace std;

//继承
class A
{
public:
	void func()
	{

	}
protected:
	int _a;

};

class B: public A
{
public:
	void f()
	{           //继承的权限是比较大的除了父类的私有不可见其他的都是可以使用的
		func(); //父类的公有可以用
		_a++;     //父类的保护也可以用
	}
protected:	
	int _b;
};


//组合
class C
{
public:
	void func()
	{

	}
protected:
	int _c;
};

class D
{
public:
	void f()
	{
		_c.func(); //组合类的公有可以使用
		//_c._a++;   //但是组合类的保护不能使用
	}
protected:
	C _c;
	int _d;
};


int main()
{
	cout << sizeof(D) << endl;
	cout << sizeof(B) << endl;

	D dd;
	dd.func(); //组合类的d对象不能直接调用func;

	B bb;
	bb.func(); //继承的子类B对象就能直接调用父类的func();

}

优先使用对象组合，而不是类继承。

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称

为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的

内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很

大的影响。派生类和基类间的依赖关系很强，耦合度高。

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象

来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复

用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。

组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被

封装。

实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有
些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用
继承，可以用组合，就用组合