【C++】多态

  • 开发
  • 10

在这里插入图片描述

目录

前言

这篇文章详细介绍了C++面向对象编程中的多态概念及其相关知识点。多态是编程中的一个核心概念，它允许使用相同的接口处理不同的数据类型。多态的实现依赖于虚函数和继承机制，通过重写虚函数，可以实现对象在运行时根据类型执行不同的操作。C++11中的override和final关键字提供了对继承和多态的更强支持。多态的原理涉及虚函数表和动态绑定，允许程序在运行时确定应调用哪个虚函数的版本。单继承和多继承关系中的虚函数表处理方式略有不同，特别是菱形继承和菱形虚拟继承需要特别注意。总的来说，多态和继承是面向对象编程中两个重要的特性，它们共同构成了软件设计的基石。

一、多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
在这里插入图片描述
举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

二、多态的定义及实现

2.1多态的构成条件

比特就业课多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如 Student 继承了 Person。Perso对象买票全价，Student 对象买票半价。
那么在继承中要构成多态还有两个条件：

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
    在这里插入图片描述

2.2 虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数。

class Person {
public:
	virtual void BuyTicket()
	{
		cout << "Person:买票-全价" << endl;
	}
};

2.3 虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

class Person {
public:
	virtual void BuyTicket() { cout << "Person : 买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "Student : 买票-半价" << endl; }
	/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，
	虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),
	但是该种写法不是很规范，不建议这样使用*/
	/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

在这里插入图片描述

虚函数重写的两个例外：

  1. 协变(基类与派生类虚函数返回值类型不同)
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

注意：这里的基类和派生类的指针或引用可以是当前基类和派生类的，也可以是其他具有继承关系的基类和派生类的。

class A
{	int _a;	};

class B : public A
{	int _b;	};

class Person {
public:
	//virtual Person* BuyTicket()
	virtual A* BuyTicket()
	{ 
		cout << "Person : 买票-全价" << endl; 
		return nullptr;
	}
};
class Student : public Person {
public:
	//virtual Student * BuyTicket()
	virtual B* BuyTicket()
	{
		cout << "Student : 买票-半价" << endl; 
		return nullptr;
	}
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

在这里插入图片描述

  1. 析构函数的重写(基类与派生类析构函数的名字不同)
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
class Person {
public:
	~Person()
	{
		cout << "~Person()" << endl;
	}
};
class Student : public Person {
public:
	~Student()
	{
		cout << "~Student()" << endl;
	}
};

int main()
{
	Person* p = new Student();
	delete p;
	return 0;
}

上述代码会导致内存泄漏，由于new的是Student的对象，但是调用析构函数的时候是调用Person的。原因是因为Person和Student的析构函数不是虚函数，不构成多态。
在这里插入图片描述

public:
	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};
class Student : public Person {
public:
	virtual ~Student()
	{
		cout << "~Student()" << endl;
	}
};

int main()
{
	Person* p = new Student();
	delete p;
	return 0;
}

在这里插入图片描述

2.4 C++11 override 和 final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

  1. final：修饰虚函数，表示该虚函数不能再被重写
class A
{
public:
	void Print() final
	{
		cout << "A:" << _a << endl;
	}
private:
	int _a;
};

class B : public A
{
	void Print()
	{
		cout << "B:" << _b << endl;
	}
private:
	int _b;
};

在这里插入图片描述

  1. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class A
{
public:
	virtual void Print() 
	{
		cout << "A:" << _a << endl;
	}
private:
	int _a;
};

class B : public A
{
	virtual void Print() override
	{
		cout << "B:" << _b << endl;
	}
private:
	int _b;
};

2.5 重载、覆盖(重写)、隐藏(重定义)的对比

在这里插入图片描述

三、抽象类

3.1 概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

注意：抽象类虽然不可以定义对象，但是可以定义指针。

class Animal
{
public:
	virtual void run() = 0;
};

class rabbit : public Animal
{
public:
	virtual void run()
	{
		cout << "rabbit - 快" << endl;
	}
};

class turtle : public Animal
{
public:
	virtual void run()
	{
		cout << "turtle - 慢" << endl;
	}
};

int main()
{
	Animal* pa = new rabbit();
	pa->run();

	pa = new turtle();
	pa->run();

	return 0;
}

在这里插入图片描述

3.2 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

四、多态的原理

4.1 虚函数表

通过观察测试我们发现bc对象是24bytes，除了_i和_d成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。那么派生类中这个表放了些什么呢？我们接着往下分析

// 这里常考一道笔试题：sizeof(Base)是多少？
class BaseClass
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _i = 1;
	double _d = 2;
};

int main()
{
	BaseClass bc;
	cout << sizeof(bc) << endl;

	return 0;
}

在这里插入图片描述

// 这里新定义一个DerivedClass类继承BaseClass
// BaseClass类新第一个虚函数Func2 和 一个普通函数 Func3
// 并且在DerivedClass类中重写Func1
class BaseClass
{
public:
	virtual void Func1()
	{
		cout << "BaseClass::Func1()" << endl;
	}

	virtual void Func2()
	{
		cout << "BaseClass::Func2()" << endl;
	}

	void Func3()
	{
		cout << "BaseClass::Func3()" << endl;
	}

private:
	int _i = 1;
	double _d = 2;
};

class DerivedClass : public BaseClass
{
public:
	virtual void Func1()
	{
		cout << "DerivedClass::Func1()" << endl;
	}

private:
	int _d = 1;
	char _c = 'c';
};


int main()
{
	BaseClass bc;
	DerivedClass dc;

	return 0;
}

在这里插入图片描述

通过观察和测试，我们发现了以下几点问题：

  1. 派生类对象dc中也有一个虚表指针，dc对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。

  2. 基类bc对象和派生类dc对象虚表是不一样的，这里我们发现Func1完成了重写，所以dc的虚表中存的是重写的DerivedClass::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。

  3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。

  4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

  5. 总结一下派生类的虚表生成：

    • 先将基类中的虚表内容拷贝一份到派生类虚表中
    • 如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
    • 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

  6. 这里还有一个大家很容易混淆的问题：虚函数存在哪的？虚表存在哪的？ 答：注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？答：虚表也存在代码段

class BaseClass
{
public:
	virtual void Func1()
	{
		cout << "BaseClass::Func1()" << endl;
	}
private:
	int _i = 1;
	double _d = 2;
};

void func()
{
	cout << "func" << endl;
}

int main()
{
	BaseClass bc;				

	int i = 10;							// 栈
	static double d = 1.1;				// 静态区
	int* pi = new int(10);				// 堆
	const char* pc = "Love";			// 代码段

	printf("静态区:%p\n", &d);
	printf("栈:%p\n", &i);
	printf("堆:%p\n", pi);
	printf("代码段:%p\n", pc);
	printf("虚表:%p\n", *((int*)&bc));
	printf("虚函数地址:%p\n", &BaseClass::Func1);
	printf("普通函数地址:%p\n", func);

	return 0;
}

在这里插入图片描述

4.2 多态的原理

上面分析了这个半天了那么多态的原理到底是什么？还记得这里Func函数传Person调用的Person::BuyTicket，传Student调用的是Student::BuyTicket

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person P;
	Func(P);
	Student S;
	Func(S);
	return 0;
}

在这里插入图片描述

  1. 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
  2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
  3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
  4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？
  5. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。
    在这里插入图片描述
class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
··18                       3

void Func(Person* p)
{
	p->BuyTicket();
}

int main()
{
	Person P;
	Func(&P);
	P.BuyTicket();
	return 0;
}
// 以下汇编代码中跟你这个问题不相关的都被去掉了
void Func(Person* p)
{
	...
	p->BuyTicket();
	// p中存的是P对象的指针，将p移动到eax中
	001940DE mov eax, dword ptr[p]
	// [eax]就是取eax值指向的内容，这里相当于把P对象头4个字节(虚表指针)移动到了edx
	001940E1 mov edx, dword ptr[eax]
	// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
	00B823EE mov eax, dword ptr[edx]
	// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的中取找的。
	001940EA call eax
	00头1940EC cmp esi, esp
}
int main()
{
	...
	// 首先BuyTicket虽然是虚函数，但是P是对象，不满足多态的条件，所以这里是普通函数的调
	用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址
	P.BuyTicket();
	00195182 lea ecx, [P]
	00195185 call Person::BuyTicket(01914F6h)
	...
}

4.3 动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

五、单继承和多继承关系的虚函数表

需要注意的是在单继承和多继承关系中，下面我们去关注的是派生类对象的虚表模型，因为基类的虚表模型前面我们已经看过了，没什么需要特别研究的

5.1 单继承中的虚函数表

class BaseClass
{
public:
	virtual void Func1()
	{
		cout << "BaseClass::Func1()" << endl;
	}

	virtual void Func2()
	{
		cout << "BaseClass::Func2()" << endl;
	}
};

class DerivedClass : public BaseClass
{
public:
	virtual void Func1()
	{
		cout << "DerivedClass::Func1()" << endl;
	}

	virtual void Func3()
	{
		cout << "DerivedClass::Func3()" << endl;
	}

	virtual void Func4()
	{
		cout << "DerivedClass::Func4()" << endl;
	}
};

int main()
{
	BaseClass bc;
	DerivedClass dc;

	return 0;
}

在这里插入图片描述

DerivedClass类中明明有四个虚函数，但是在vs的监视窗口中看到_vfptr中只有两个虚函数的地址，那么DerivedClass类中真的只有两个虚函数吗？我们使用代码将DerivedClass类中的函数地址打印出来。

class BaseClass
{
public:
	virtual void Func1()
	{
		cout << "BaseClass::Func1()" << endl;
	}

	virtual void Func2()
	{
		cout << "BaseClass::Func2()" << endl;
	}
};

class DerivedClass : public BaseClass
{
public:
	virtual void Func1()
	{
		cout << "DerivedClass::Func1()" << endl;
	}

	virtual void Func3()
	{
		cout << "DerivedClass::Func3()" << endl;
	}

	virtual void Func4()
	{
		cout << "DerivedClass::Func4()" << endl;
	}
};

typedef void (*_vfptr)();      //函数指针

void PrintVFPtr(_vfptr* vf)
{
	cout << "虚表地址：" << vf <<  endl;
	for (int i = 0; vf[i] != nullptr ;i++)
	{
		printf("vf[%d]:%p\n",i,vf[i]);
	}
	cout << endl;
}

int main()
{
	BaseClass bc;
	DerivedClass dc;

	// 打印BaseClass类的虚函数
	PrintVFPtr((_vfptr*)(*((int*)&bc)));

	// 打印DerivedClass类的虚函数
	PrintVFPtr((_vfptr*)(*((int*)&dc)));
	// 首先虚表地址存在对象的前四个字节
	// 并且虚表最后会有nullptr结尾
	// 这里我们先取dc的地址强转为int*
	// 解引用就是取到前四个字节的数据
	// 虚表中存储的是函数的地址，那么虚表就是一个函数指针数组
	// 这里将函数指针void (*)()重命名为_vfptr
	// 得到虚表地址后，再将类型强转为_vfptr*
	// 那么就可以通过for循环来遍历虚表，直到遍历到nullptr结束
	return 0;
}

在这里插入图片描述

在这里插入图片描述

5.2 多继承中的虚函数表

class BaseClass1
{
public:
	virtual void Func1()
	{
		cout << "BaseClass1::Func1()" << endl;
	}

	virtual void Func2()
	{
		cout << "BaseClass2::Func2()" << endl;
	}
};

class BaseClass2
{
public:
	virtual void Func1()
	{
		cout << "BaseClass1::Func1()" << endl;
	}

	virtual void Func2()
	{
		cout << "BaseClass2::Func2()" << endl;
	}
};

class DerivedClass :
	public BaseClass1, public BaseClass2
{
public:
	virtual void Func1()
	{
		cout << "DerivedClass::Func1()" << endl;
	}

	virtual void Func3()
	{
		cout << "DerivedClass::Func3()" << endl;
	}

	virtual void Func4()
	{
		cout << "DerivedClass::Func4()" << endl;
	}
};

typedef void (*_vfptr)();      //函数指针

void PrintVFPtr(_vfptr* vf)
{
	cout << "虚表地址：" << vf <<  endl;
	for (int i = 0; vf[i] != nullptr ;i++)
	{
		printf("vf[%d]:%p->",i,vf[i]);
		vf[i]();
	}
	cout << endl;
}

int main()
{
	DerivedClass dc;

	// 打印DerivedClass类的第一张虚表
	PrintVFPtr((_vfptr*)(*((int*)&dc)));

	// 打印DerivedClass类的第二张虚表
	PrintVFPtr((_vfptr*)(*(int*)((char*)&dc + sizeof(BaseClass1))));

	// 切片，打印DerivedClass类的第二张虚表
	BaseClass2* pbc = &dc;
	PrintVFPtr((_vfptr*)(*(int*)pbc));

	return 0;
}

派生类DerivedClass继承了两个基类，由下图可以得到，派生类继承了多少个拥有虚函数的基类，那么派生类就有多少个虚表。基类中的虚函数都被记录在对应的虚表中，那么派生类中的虚函数被存在了哪个虚表？还是说派生类也有一个自己的虚表。下面我们用代码来打印一下派生类虚表中的虚函数的地址。

在这里插入图片描述

int main()
{
	DerivedClass dc;

	// 打印DerivedClass类的第一张虚表
	PrintVFPtr((_vfptr*)(*((int*)&dc)));

	// 打印DerivedClass类的第二张虚表
	PrintVFPtr((_vfptr*)(*(int*)((char*)&dc + sizeof(BaseClass1))));

	// 切片，打印DerivedClass类的第二张虚表
	BaseClass2* pbc = &dc;
	PrintVFPtr((_vfptr*)(*(int*)pbc));

	return 0;
}

基类的虚表被存储在派生类对象的每个基类子对象中，这里要访问第二个虚表，那么就让对象的地址加上BaseClass1的大小就可以访问到第二个虚表了，或者使用一个BaseClass2的指针指向DerivedClass的对象，取到前4个字节，再强转为_vfptr*就可以访问虚表了。

通过下面的图可以知道，多继承派生类中未重写的虚函数的地址都被存放第一个虚表中。
在这里插入图片描述

通过上面的图片我们可以发现一个问题，那就是DerivedClass的Func1重写了BaseClass1和BaseClass2的Func1，我们可以看到打印虚表时，两张虚表调用的Func1是同一个Func1，但是两个Func1的地址却不是相同的，这是为什么？

在这里插入图片描述
从上面的图我们可以看到pbc1调用Func1时只跳转了2次，而pbc2调用Func2却调用了4次，为什么呢？ecx一般存储的是this指针，而这里存储的是pbc2，而跳转两次后可以看到ecx-4，由于BaseClass中没有成员变量，只有虚函数，那么BaseClass的对象只有一张虚表，虚表的大小是4，那么这里ecx-4就是使this指针指向DerivedClass对象的开头。pbc1和pbc2调用的是DerivedClass中的Func1，而DerivedClass中的Func1的隐藏参数this指针指向的是整个DerivedClass对象，所以pbc2调用Func1跳转多次的原因就是修正this指针，使this指针指向DerivedClass对象的开头。

5.3. 菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。

六、继承和多态常见的问题

  1. 什么是多态？
    解答：多态简而言之就是一种事物的多种形态。
    C++中的多态就是不同对象调用相同的函数完成后会得到不同的结果。

  2. 什么是重载、重写(覆盖)、重定义(隐藏)？
    解答：
    在这里插入图片描述

  3. 多态的实现原理？
    解答：多态的实现原理是基于继承和虚函数的机制。基类对象和派生类对象中都有虚函数表，虚函数表中存储了类中虚函数的地址，当我们调用函数时，会通过对象中的虚函数表而找到对应的函数调用，做到谁的指针/引用调用就调用谁的函数，从而实现多态。

  4. inline函数可以是虚函数吗？
    解答：可以，普通调用时具有inline的特性，多态调用时不具有inline特性，下面使用一段代码进行解释。

class BaseClass
{
public:
	inline virtual void Func1()
	{
		cout << "BaseClass::Func1()" << endl;
	}
};

class DerivedClass : public BaseClass
{
public:
	inline virtual void Func1()
	{
		cout << "DerivedClass::Func1()" << endl;
	}
};


int main()
{
	BaseClass* pb = new DerivedClass();
	pb->Func1();

	// DerivedClass* pd = new DerivedClass();
	DerivedClass* pd = new DerivedClass();
	pd->Func1();

	DerivedClass dc ;
	dc.Func1();

	return 0;
}

从下面这张图片我们可以看到，第一次和第二次调用Func1函数时，是call地址，而第三次调用Func1时则是Func1在调用处直接展开。所以说，普通调用时具有inline的特性，多态调用时不具有inline特性。

有人会有疑问，第二次调用时，明明是派生类的指针指向派生类对象然后再调用Func1，那么这里为什么是多态调用？

解答：原因是这里编译器不敢不按多态的方式走，虽然说这里是使用派生类的指针进行调用，但是它不能保证后面或者其他地方没有类继承它，所以多态中只要是类类型的指针调用虚函数，不管是指向的基类还是派生类都会按照多态的方式走。
在这里插入图片描述

  1. 静态成员可以是虚函数吗？
    解答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

  2. 构造函数可以是虚函数吗？
    解答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的，如果将构造函数定义为虚函数，那么构造函数的地址就存在虚函数表中。虚函数表在调用构造函数时初始化，而构造函数的地址又在虚函数表中，逻辑会出现问题。

  3. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？
    解答：可以，并且最好把基类的析构函数定义成虚函数。下面这张图片就是将虚函数分别调用虚函数和不是虚函数，很明显当基类指针指向一个new出来的派生类对象时析构派生类对象时，
    在这里插入图片描述

  4. 对象访问普通函数快还是虚函数更快？
    解答：普通调用一样快。多态调用普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

  5. 虚函数表是在什么阶段生成的，存在哪的？
    解答：虚函数表是在编译阶段就生成的，一般情况下存在代码段。

  6. C++菱形继承的问题？虚继承的原理？
    解答：菱形继承有数据冗余和二义性的问题，注意这里不要把虚函数表和虚基表搞混了。
    虚继承的原理是在派生类对共同的基类使用虚继承，这样在派生类对象中只包含一份共同的基类子对象，而不会重复。虚继承会在派生类对象中添加一个虚基表指针，指向共同基类的虚基表，确保只有一份共同基类的实例存在。

  7. 什么是抽象类？抽象类的作用？
    解答：在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。
    抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。

结尾

如果有什么建议和疑问，或是有什么错误，大家可以在评论区中提出。
希望大家以后也能和我一起进步！！🌹🌹
如果这篇文章对你有用的话，希望大家给一个三连支持一下！！🌹🌹

在这里插入图片描述

阅读全部

相关推荐

  5. <span style='color:red;'>C</span>++<span style='color:red;'>多</span><span style='color:red;'>态</span>

    C++多态

    2024-05-25 23:38:24      26 阅读

  6. 八股文 c++ 多态

    2024-05-25 23:38:24       28 阅读

最近更新

  4. TCP协议是安全的吗?

    2024-05-25 23:38:24       18 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-05-25 23:38:24       19 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-05-25 23:38:24       19 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-05-25 23:38:24       20 阅读

热门阅读

  2. H.264 的RTP 三种封包模式

    2024-05-25 23:38:24       11 阅读

  6. docker迁移根目录导致的权限问题

    2024-05-25 23:38:24       13 阅读

  7. docker 安装RabbitMQ

    2024-05-25 23:38:24       12 阅读

  8. SQL的多表联查

    2024-05-25 23:38:24       11 阅读

  18. ZJGSU 2199 图论1

    2024-05-25 23:38:24       11 阅读

  28. C++11-独占指针unique_ptr原理实现

    2024-05-25 23:38:24       13 阅读

  29. Spring Boot ：从上传的二维码图片中读取信息

    2024-05-25 23:38:24       12 阅读

  30. 第八届“英拿科技杯”上海高校金马程序设计联赛暨东华大学邀请赛——源石虫（基础DP）

    2024-05-25 23:38:24       12 阅读