【继承和多态】

闭上眼睛，什么都不听..............................................................................................................

文章目录

前言

一、【继承】

1.1【继承的概念】

[1.2【 继承的定义】](#1.2【 继承的定义】)

1.2.1【定义格式】

1.2.2【继承关系和访问限定符】

1.2.3【继承基类成员的九种访问方式】

1.2.4【基类和派生类对象赋值转换】

1.3【继承中的作用域】

1.4【派生类的默认成员函数】

1.5【继承与友元】

1.6【继承与静态成员】

1.7【菱形虚拟继承】

1.7.1【介绍及存在问题】

1.7.2【菱形虚拟继承原理】

1.8【继承的总结和反思】

1.9【相关笔试面试题】

二、【多态】

[1.1 【多态的概念】](#1.1 【多态的概念】)

[2.2 【多态的定义】](#2.2 【多态的定义】)

2.2.1【多态的构成条件】

1.虚函数

2.虚函数的重写

​编辑

3.虚函数重写的两个例外

[1. 协变](#1. 协变)

2、析构函数的重写

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

[2.3【override 和 final】](#2.3【override 和 final】)

1、final

2、override

2.4【抽象类】

[1、 概念及使用](#1、 概念及使用)

2、接口继承和实现继承

2.5【多态的原理】

1、虚函数表

2.【多态的原理】

2.6【单继承和多继承关系的虚函数表】

1、【单继承中的虚函数表】

2.【多继承中的虚函数表】

2.7【菱形继承、菱形虚拟继承】

2.8【继承和多态常见的面试问题】

总结

---

前言

继承和多态是C++这门面向对象语言十分重要的语法，它们对于提高C++代码的简洁性和可复用行有着重要的作用，同时继承和多态也符合我们现实生活中的绝大多数场景。

---

一、【继承】

1.1【继承的概念】

参考了大佬的博客:C++继承_#include<iosteram>using namespac-CSDN博客

继承(inheritance)机制是一种面向对象程序设计，能够使代码复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类(子类)。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

比如这里举个例子：

#include <iostream>
using namespace std;
class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "peter"; // 姓名
	int _age = 18; // 年龄
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了
//Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可
//以看到变量的复用。调用Print可以看到成员函数的复用。
class Student : public Person
{
protected:
	int _stuid; // 学号
};
class Teacher : public Person
{
protected:
	int _jobid; // 工号
};
int main()
{
	Student s;
	Teacher t;
	s.Print();
	t.Print();
	return 0;
}

1.2【 继承的定义】

1.2.1【定义格式】

下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。

在上面所举的例子中，Person被称作基类(父类)，Student被称作派生类(子类)，继承方式主要有3种分别是公有继承(public)，保护继承(protected)，私有继承(private)，上面所采用的是公有继承，3者的区别见下面的模块。

1.2.2【继承关系和访问限定符】

学习类和对象时，我们知道成员变量的属性或者说访问限定符主要有三种：

1. public访问
2. protected访问
3. private访问

而上面说，继承也有3种方式：

1. public继承
2. protected继承
3. private继承

那么共有9种组合方式，那么这九种组合方式有什么区别呢？

1.2.3【继承基类成员的九种访问方式】

总结：

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符（protected）是因继承才出现的。
3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，标准为：public > protected> private。
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过
   最好显示的写出继承方式。
5. 在实际运用中一般使用都是public继承，加父类protected成员，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

【九种方式的示例】：

1.父类私有成员，子类任意方式继承

2.父类保护成员，子类任意方式继承

3.父类公有成员子类任意方式继承

基类的private成员在派生类当中不可见是什么意思？

这句话的意思是，我们无法在派生类当中访问基类的private成员。例如，虽然Student类继承了Person类，但是我们无法在Student类当中访问Person类当中的private成员_name。

注意：

我们在使用在使用继承的时候也可以不指定继承方式，使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。

虽然可以不写，但是一般我们还是写上派生类的继承方式。

1.2.4【基类和派生类对象赋值转换】

1、派生类对象 可以赋值给 （基类的对象 / 基类的指针 / 基类的引用）。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切出来赋值过去给子类。

具体如下图：

派生类对象赋值给基类对象图示：

派生类对象指针赋值给基类指针图示：

派生类对象赋值引用给基类引用图示：

2、但是基类对象不能赋值给派生类对象。

3、基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是此时基类的指针必须指向派生类对象，因为只有这样赋值才是安全的。这里基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast (dynamic_cast_百度百科)来进行识别后进行安全转换。

下面看具体的例子：

void Test()
{
	//先定义一个Student对象，并将其成员进行初始化。
	Student sobj;
	sobj._age = 12;
	sobj._name = "Alex";
	sobj._sex = "man";
	sobj._No = 222;
	cout << "sobj的各成员" << endl;
	sobj.Print();

	// 1.子类对象可以赋值给父类对象/指针/引用
	Person pobj = sobj;
	cout << "pobj的各成员" << endl;
	pobj.Print_Person();
	cout << "pp的各成员" << endl;
	Person* pp = &sobj;
	pp->Print_Person();
	Person& rp = sobj;
	cout << "rp的各成员" << endl;
	rp.Print_Person();



	//2.基类对象不能赋值给派生类对象
	//sobj = pobj;//error




	// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
	pp = &sobj;
	Student* ps1 = (Student*)pp; // 将pp的值赋值给ps1，让其指向sobj，这种情况转换时可以的。
	ps1->_No = 10;
	cout << "ps1的各成员" << endl;
	ps1->Print();


	//pp = &pobj;//这里也会报错，由于pp指向的对象是基类而不是派生类，不安全
	//Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
	//ps2->_No = 10;
}

注意：

什么是is-a,就是说子类is-a父类，就像上面的Student is-a Person，满足is-a的关系，就能够使用继承，进而能够使用赋值，除了is-a还有has-a，常用在"组合"（表示子类不继承父类而是将声明一个父类对象的成员变量）当中，即父类has-a子类。比如车类has-a轮胎类。

1.3【继承中的作用域】

1. 在继承体系中基类和派生类都有独立的作用域。

下面看一个例子：

class Person
{
protected:
	int _num = 111;
};
//子类
class Student : public Person
{
public:
	void fun1()
	{
		cout << _num << endl;
	}
	void func2()
	{
		cout <<Person:: _num << endl;
	}
protected:
	int _num = 999;
};
int main()
{
	Student s;
	s.fun1(); //999
	//如果想访问父类中的成员就需要加上父类的访问限定符
	s.func2();
	return 0;
}

2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

再看一个例子：

class Person
{
public:
	void fun(int x)
	{
		cout << x << endl;
	}
};
//子类
class Student : public Person
{
public:
	void fun(double x)
	{
		cout << x << endl;
	}
};
int main()
{
	Student s;
	s.fun(3.14);       //直接调用子类当中的成员函数fun
	s.Person::fun(20); //指定调用父类当中的成员函数fun
	return 0;
}

注意： 代码当中，父类中的fun和子类中的fun不是构成函数重载，因为函数重载要求两个函数在同一作用域，而此时这两个fun函数并不在同一作用域。

4. 注意在实际中在继承体系里面最好不要定义同名的成员。

5.这里要注意父子类的析构函数也构成隐藏，虽然表面上两个类的析构函数名称并不相同，但是编译器统一处理成了，destructor,具体原因在析构函数中会讲到。

注意：

1、父类和子类可以有同名成员，因为他们是独立作用域

2、默认情况直接访问是子类的，子类同名成员隐藏父类同名成员

3、继承中，同名的成员函数，函数名相同就构成隐藏，不管参数和返回值

1.4【派生类的默认成员函数】

派生类总共有6个默认成员函数，"默认"的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

下面看一个例子：

//基类
class Person
{
public:
	//构造函数
	Person(const string& name = "peter")
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	//拷贝构造函数
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	//赋值运算符重载函数
	Person& operator=(const Person& p)
	{
		cout << "Person& operator=(const Person& p)" << endl;
		if (this != &p)
		{
			_name = p._name;
		}
		return *this;
	}
	//析构函数
	~Person()
	{
		cout << "~Person()" << endl;
	}
private:
	string _name; //姓名
};



//派生类
class Student : public Person
{
public:
	//构造函数
	Student(const string& name, int id)
		:Person(name) //调用基类的构造函数初始化基类的那一部分成员
		, _id(id) //初始化派生类的成员
	{
		cout << "Student()" << endl;
	}
	//拷贝构造函数
	Student(const Student& s)
		:Person(s) //调用基类的拷贝构造函数完成基类成员的拷贝构造,由于可以将一个派生类赋值给基类，这里直接进行切片即可。
		, _id(s._id) //拷贝构造派生类的成员
	{
		cout << "Student(const Student& s)" << endl;
	}
	//赋值运算符重载函数
	Student& operator=(const Student& s)
	{
		cout << "Student& operator=(const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator=(s); //调用基类的operator=完成基类成员的赋值，这里要加访问限定符确保调用的是父类，防止无限递归
			_id = s._id; //完成派生类成员的赋值
		}
		return *this;
	}
	//析构函数
	~Student()
	{
		cout << "~Student()" << endl;
		//派生类的析构函数会在被调用完成后自动调用基类的析构函数，这里会详细讲解。
	}
private:
	int _id; //学号
};

其中我们可能会有疑问，为什么Student的析构函数不写成：

//析构函数
	~Student()
	{
		cout << "~Student()" << endl;
		//派生类的析构函数会在被调用完成后自动调用基类的析构函数，这里会详细讲解。
        Person::~Person();
	}

由于我们要安全的析构，就应该先析构子类再析构父类，如果反过来，那么子类有可能会访问父类成员，造成内存泄漏，但是上面的写法好像也体现了先子后父了呢，我们为什么不按上面的写法写呢？

我们看一下下面的例子：

说明一下：
基类的构造函数、拷贝构造函数、赋值运算符重载函数我们都可以在派生类当中自行进行调用，而基类的析构函数是当派生类的析构函数被调用后由编译器自动调用的，我们若是自行调用基类的构造函数就会导致基类被析构多次的问题。

我们知道，创建派生类对象时是先创建的基类成员再创建的派生类成员，所以在析构时会先析构派生类成员，再析构基类成员，编译器为了保证析构时先析构派生类成员再析构基类成员的顺序析构，所以编译器会在派生类的析构函数被调用后自动调用基类的析构函数。

具体要点如下：

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

【注意】

在编写派生类的默认成员函数时，需要注意以下几点：

1、派生类和基类的赋值运算符重载函数（operator=）因为函数名相同构成隐藏，因此在派生类当中调用基类的赋值运算符重载函数时，需要使用作用域限定符进行指定调用。

2、由于多态的某些原因，任何类的析构函数名都会被统一处理为destructor();。因此，派生类和基类的析构函数也会因为函数名相同构成隐藏，若是我们需要在某处调用基类的析构函数，那么就要使用作用域限定符进行指定调用。

3、在派生类的拷贝构造函数和operator=当中调用基类的拷贝构造函数和operator=的传参方式是一个切片行为，都是将派生类对象直接赋值给基类的引用。

1.5【继承与友元】

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

简单来说就是父亲的朋友不一定是你的朋友，所以不能访问父亲的朋友，想要访问就要把父亲的朋友变为你的朋友。

下面看一个例子：

class Student;
class Person
{
public:
	//声明Display是Person的友元
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; //姓名
};
class Student : public Person
{
protected:
	//friend void Display(const Person& p, const Student& s);//加上才能访问
	int _id; //学号
};
void Display(const Person& p, const Student& s)
{
	cout << p._name << endl; //可以访问
	cout << s._id << endl; //无法访问
}
int main()
{
	Person p;
	Student s;
	Display(p, s);
	return 0;
}

1.6【继承与静态成员】

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子

类，都只有一个static成员实例 。

需要注意的是，静态数据成员必须在类外部进行定义和初始化。

主要是因为静态成员主要放在静态区(数据段)，一旦定义仅仅存在一份，并且任何子类对其进行修改都是对其本体进行修改。

举个例子：

//基类
class Person
{
public:
	Person()
	{
		_count++;
	}
	Person(const Person& p)
	{
		_count++;
	}
protected:
	string _name; //姓名
public:
	static int _count; //统计人的个数。
};
int Person::_count = 0; //静态成员变量在类外进行初始化
//派生类
class Student : public Person
{
protected:
	int _stuNum; //学号
};
//派生类
class Graduate : public Person
{
protected:
	string _seminarCourse; //研究科目
};
int main()
{
	Student s1;
	Student s2(s1);
	Student s3;
	Graduate s4;
	cout << Person::_count << endl; //4
	cout << Student::_count << endl; //4
	cout << &Person::_count << endl; //4
	cout << &Student::_count << endl; //4
	return 0;
}

可以看到，两个基类中的_count是同一个成员。

1.7【菱形虚拟继承】

1.7.1【介绍及存在问题】

在介绍菱形继承之前，要先了解单继承和多继承。

1、单继承：

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

2、多继承：

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

3、菱形继承：

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

那么什么是菱形继承，就像它的名字一样，菱形继承中各个类的继承关系就像菱形一样,具体如下：

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题即在Assistant的对象中Person成员会有两份。

下面看一个例子：

class Person
{
public:
	string _name; //姓名
};
class Student : public Person
{
protected:
	int _num; //学号
};
class Teacher : public Person
{
protected:
	int _id; //职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; //主修课程
};
int main()
{
	Assistant a;
	//a._name = "peter";//二义性：无法明确知道要访问哪一个_name
	a.Student::_name = "Alex";
	a.Teacher::_name = "Blex";
	cout << &(a.Student::_name) << endl;
	cout << &(a.Teacher::_name) << endl;
	return 0;
}

Assistant对象是多继承的Student和Teacher，而Student和Teacher当中都继承了Person，因此Student和Teacher当中都有_name成员，若是直接访问Assistant对象的_name成员会出现访问不明确的报错，因为编译器并不知道，_name具体指哪个类的成员。

对于此，我们可以显示指定访问Assistant哪个父类的_name成员。

虽然该方法可以解决二义性的问题，但仍然不能解决数据冗余的问题。因为在Assistant的对象在Person成员始终会存在两份。

那么如何解决数据冗余的问题呢？

这里就需要用到虚拟继承，虚拟继承可以解决菱形继承的二义性和数据冗余的问题。比如对于上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

具体的使用方法如下：

在中间类中加上virtual，这里的中间类是指同时继承A类的两个类B，C又被D类所继承，这时就可以在B类和C类继承A类的方式上加上virtual关键字。

此时就可以直接访问Assistant对象的_name成员了，并且之后就算我们指定访问Assistant的Student父类和Teacher父类的_name成员，访问到的都是同一个结果，解决了二义性的问题。这里同一个结果指的是，C++采用了虚拟继承将菱形继承中的冗余数据处理成了类似于静态成员一样，只有一份。

具体看下面的例子：

class Person
{
public:
	string _name; //姓名
};
class Student :virtual  public Person
{
protected:
	int _num; //学号
};
class Teacher :virtual  public Person
{
protected:
	int _id; //职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; //主修课程
};
int main()
{
	Assistant a;
	a._name = "peter";//二义性：无法明确知道要访问哪一个_name
	cout << &(a.Student::_name) << endl;
	cout << &(a.Teacher::_name) << endl;
	return 0;
}

1.7.2【菱形虚拟继承原理】

在此之前，我们先看看不使用菱形虚拟继承时，以下菱形继承当中D类对象的各个成员在内存当中的分布情况。

使用下面的简单代码：

class A
{
public:
	int _a;
};
class B : public A
{
public:
	int _b;
};
class C : 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;
}

也就是说，D类对象当中各个成员在内存当中的分布情况如下：

这里就可以看出为什么菱形继承导致了数据冗余和二义性，根本原因就是D类对象当中含有两个_a成员。

现在我们再来看看使用菱形虚拟继承时，以下菱形继承当中D类对象的各个成员在内存当中的分布情况。

#include <iostream>
using namespace std;
class A
{
public:
	int _a;
};
class B : virtual public A
{
public:
	int _b;
};
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;
}

这里只观察内存窗口：

当执行到，d.B::_a=1 ;时主要内存分布如下，此时d中的_a为1。

继续向下执行，可以发现，_a的值已经将发生了改变。

下图是菱形虚拟继承的内存对象成员模型：

这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。

还有一个问题，就是为什么d的地址会和d中B类的地址相同？

这是因为他们指向的位置相同，但是作用效果不同，比如d的地址指向一个D类对象，控制的也是整个D类对象，而B类的地址控制的则是一个B类对象，由于D先继承的B类所以首先存放B，具体见下图：

可以通过一个题目更好的理解上面的现象：

class Base1 
{ 
public: 
	int _b1; 
};
class Base2 
{
public: 
	int _b2;
};
class Derive : public Base1, public Base2 
{
public: 
	int _d;
};
int main() 
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;

	return 0;
}

我们若是将D类对象赋值给B类对象，在这个切片过程中，就需要通过虚基表中的第二个数据找到公共虚基类A的成员，得到切片后该B类对象在内存中仍然保持这种分布情况。其中，_a对象仍然存储在该B类对象的最后。不同的编译器_a的存放位置不同。

下面是上面的Person关系菱形虚拟继承的原理解释：

1.8【继承的总结和反思】

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来的OOP语言都没有多继承，如Java。

3. 继承和组合的使用

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。

组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

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

参考下面的资料：

（https://www.cnblogs.com/nexiyi/archive/2013/06/16/3138568.html）

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

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

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

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

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

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

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

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

封装。

实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有

些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用

继承，可以用组合，就用组合。

例如，车类和宝马类就是is-a的关系，它们之间适合使用继承。宝马is-a车

class Car
{
protected:
	string _colour; //颜色
	string _num; //车牌号
};
class BMW : public Car
{
public:
	void Drive()
	{
		cout << "this is BMW" << endl;
	}
};

而车和轮胎之间就是has-a的关系，它们之间则适合使用组合。

class Tire
{
protected:
	string _brand; //品牌
	size_t _size; //尺寸
};
class Car
{
protected:
	string _colour; //颜色
	string _num; //车牌号
	Tire _t; //轮胎
};

注意：

组合是在一个类中将另一个类作为自己的成员，与内部类区分，内部类是一种友元类，是在一个类的内部实现另一个类。

如果存在两个类之间既可以看作is-a的关系，又可以看作has-a的关系，则优先使用组合。

原因如下：

继承允许你根据基类的实现来定义派生类的实现，这种通过生成派生类的复用通常被称为白箱复用(White-boxreuse)。术语"白箱"是相对可视性而言：在继承方式中，基类的内部细节对于派生类可见，继承一定程度破坏了基类的封装，基类的改变对派生类有很大的影响，派生类和基类间的依赖性关系很强，耦合度高。

组合是类继承之外的另一种复用选择，新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口，这种复用风格被称之为黑箱复用(Black-box reuse)，因为对象的内部细节是不可见的，对象只以"黑箱"的形式出现，组合类之间没有很强的依赖关系，耦合度低，优先使用对象组合有助于你保持每个类被封装。

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

1.9【相关笔试面试题】

1、什么是菱形继承？菱形继承的问题是什么？

菱形继承是多继承的一种特殊情况，两个子类继承同一个父类，而又有子类同时继承这两个子类，我们称这种继承为菱形继承。菱形继承因为子类对象当中会有两份父类的成员，因此会导致数据冗余和二义性的问题。

2、什么是菱形虚拟继承？如何解决数据冗余和二义性？

菱形虚拟继承是指在菱形继承的腰部使用虚拟继承(virtual)的继承方式，菱形虚拟继承对于D类对象当中重复的A类成员只存储一份，然后采用虚基表指针和虚基表使得D类对象当中继承的B类和C类可以找到自己继承的A类成员，从而解决了数据冗余和二义性的问题。

3、继承和组合的区别？什么时候用继承？什么时候用组合？

继承是一种is-a的关系，而组合是一种has-a的关系。如果两个类之间是is-a的关系，使用继承；如果两个类之间是has-a的关系，则使用组合；如果两个类之间的关系既可以看作is-a的关系，又可以看作has-a的关系，则优先使用组合。

二、【多态】

参考了大佬的博客：C++多态_drogon c++-CSDN博客

1.1 【多态的概念】

【多态的概念】：

多态就是函数调用的多种形态，使用多态能够使得不同的对象去完成同一件事时，产生不同的动作和结果。

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个例子：

比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。
再举个例子：

最近为了争夺在线支付市场，支付宝年底经常会做诱人的扫红包-支付-给奖励金的

活动。那么大家想想为什么有人扫的红包又大又新鲜8块、10块...，而有人扫的红包都是1毛，5毛....。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如你没有经常支付宝支付等等，那么你需要被鼓励使用支付宝，那么就你扫码金额 =random()%99；比如你经常使用支付宝支付或者支付宝账户中常年没钱，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 = random()%1；总结一下：同样是扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。

2.2 【多态的构成条件】

1.多态的定义

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了

Person。Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：

1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

那么什么是虚函数，什么又是虚函数重写呢？

2.虚函数

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

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

需要注意的是：

1、只有类的非静态成员函数前可以加virtual，普通函数前不能加virtual。

2、虚函数这里的virtual和虚继承中的virtual是同一个关键字，但是它们之间没有任何关系。虚函数这里的virtual是为了实现多态，而虚继承的virtual是为了解决菱形继承的数据冗余和二义性。

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

注意： 在重写基类虚函数时，派生类的虚函数不加virtual关键字也可以构成重写，主要原因是因为继承后基类的虚函数被继承下来了，在派生类中依旧保持虚函数属性。但是这种写法不是很规范，因此建议在派生类的虚函数前也加上virtual关键字。

下面看一个题目，让我们更直观的认识到子类重写基类虚函数，重写的是基类虚函数的实现，而继承了基类虚函数的属性：

class A
{
public:
	virtual void func(int val = 1)//基类虚函数，缺省值为1
	{
		std::cout << "A->" << val << std::endl;
	}
	virtual void test() //基类虚函数，this为A*
	{
		func();
	}
};
class B : public A
{
public:
	void func(int val = 0) //重写基类虚函数，缺省值为0
	{ 
		std::cout << "B->" << val << std::endl;
	}
};
int main(int argc, char* argv[])
{
	B* p = new B;//定义子类对象
	p->test();//调用test，这里test为A的成员函数，存放在代码段，由于B继承A，那么B拥有使用test的权
	return 0; //力。
}

总的来说，虚函数的重写就是与基类虚函数同名的子类虚函数在满足三同的情况下，子类的虚函数会继承父类虚函数虚的属性（就是指子类虚函数可以不写virtual），同时在子类虚函数中对父类虚函数的实现部分进行重写，这样就构成了虚函数重写，进而可以形成多态。

4.虚函数重写的两个例外

1. 协变

(基类与派生类虚函数返回值类型不同，但是返回类型之间必须构成父子类关系)

当派生类重写基类虚函数时，如果子类虚函数与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回对应派生类对象的指针或者引用时（也就是两者都返回父子类关系的指针或者引用），就构成了协变。

这里同样举个例子：

下列代码中基类Person当中的虚函数fun的返回值类型是基类A对象的指针，派生类Student当中的虚函数fun的返回值类型是派生类B对象的指针，此时也认为派生类Student的虚函数重写了基类Person的虚函数。

class A
{};
class B : public A
{};
class Person
{
public:
	virtual A* fun()//虚函数，函数名为fun,返回类型为A*
	{
		cout << "A* Person::f()" << endl;
		return new A;
	}
};
class Student : public Person
{
public:
	virtual B* fun()
	{
		cout << "B* Student::f()" << endl;
		return new B;//虚函数，函数名为fun返回类型为B*
	}
};//因为A和B也构成父子关系，基类虚函数f和派生类虚函数构成协变

此时，我们通过父类Person的指针调用虚函数fun，父类指针若指向的是父类对象，则调用父类的虚函数，父类指针若指向的是子类对象，则调用子类的虚函数。

int main()
{
	Person p;
	Student st;
	//父类指针指向父类对象
	Person* ptr1 = &p;
	//父类指针指向子类对象
	Person* ptr2 = &st;
	//父类指针ptr1指向的p是父类对象，调用父类的虚函数
	ptr1->fun(); //A* Person::f()
	//父类指针ptr2指向的st是子类对象，调用子类的虚函数
	ptr2->fun(); //B* Student::f()
	return 0;
}

所以此时Person和Student构成了协变。

2、析构函数的重写

(基类与派生类析构函数的名字不同)

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，

都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

举个例子，下面的Person和Student构成了重写：

class Person 
{
public:
	virtual ~Person() 
	{ 
		cout << "~Person()" << endl;
	}
};
class Student : public Person 
{
public:
	~Student() //写成这样派生类不带virtual的也可以
	{ 
		cout << "~Student()" << endl;
	}
   /*virtual ~Student()
	{
		cout << "~Student()" << endl;
	}*/
};

那父类和子类的析构函数构成重写有什么用呢？

试想以下场景：分别new一个父类对象和子类对象，并均用父类指针指向它们，然后分别用delete调用析构函数并释放对象空间。

首先来看下面这种写法：

// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
//数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
	Person* p = new Person;
	delete p;// p->destrutor() + operator delete(p)
	p = new Student;//满足多态条件，基类指针指向子类，delete p的时候，基类指针p调用虚函数，
	delete p;// p->destrutor() + operator delete(p)
	return 0;
}

上面写法体现了多态，基类指针指向基类调用基类析构，指向子类调用基类析构的重写

或者这种写法：

int main()
{
	//分别new一个父类对象和子类对象，并均用父类指针指向它们
	Person* p1 = new Person;
	Person* p2 = new Student;

	//使用delete调用析构函数并释放对象空间
	delete p1;
	delete p2;
	return 0;
}

在这种场景下，若是父类和子类的析构函数没有构成重写就可能会导致内存泄漏，因为此时delete p1和delete p2都是调用的父类的析构函数，而我们所期望的是p1调用父类的析构函数，p2调用子类的析构函数，即我们期望的是一种多态行为。

此时只有父类和子类的析构函数构成了重写，才能使得delete按照我们的预期进行析构函数的调用，才能实现多态。因此，为了避免出现这种情况，比较建议将父类的析构函数定义为虚函数。

总结：

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

2.3【override 和 final】

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

1、final

修饰虚函数，表示该虚函数不能再被重写,如果用来修饰类则表示该类不能在被继承。

举个例子：

父类Person的虚函数BuyTicket被final修饰后就不能再被重写了，子类若是重写了父类的BuyTicket函数则编译报错。

class Person
{
public:
	//被final修饰，该虚函数不能再被重写
	virtual void BuyTicket() final
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//重写，编译报错
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//重写，编译报错
	virtual void BuyTicket()
	{
		cout << "优先-买票" << endl;
	}
};

而如果在Person类后加上final，则表示Person类不能被继承。

//父类
class Person final
{
public:
	//被final修饰，该虚函数不能再被重写
	virtual void BuyTicket() 
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//重写，编译报错
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//重写，编译报错
	virtual void BuyTicket()
	{
		cout << "优先-买票" << endl;
	}
};

2、override

检查派生类虚函数是否重写了基类的某个虚函数，如果没有重写则编译报错。

举个例子：

子类Student和Soldier的虚函数BuyTicket被override修饰，编译时就会检查子类的这两个BuyTicket函数是否重写了父类的虚函数，如果没有则会编译报错。

//父类
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//子类完成了父类虚函数的重写，编译通过
	virtual void BuyTicket() override
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//子类没有完成对父类虚函数的重写，编译报错
	virtual void BuyTicket(int i) override//这里不满足三同
	{
		cout << "优先-买票" << endl;
	}
};

2.4【抽象类】

1、 概念及使用

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。

举个例子：

//抽象类（接口类）
class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};
int main()
{
	Car c; //抽象类不能实例化出对象，error
	return 0;
}

派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

//抽象类（接口类）
class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};
//派生类
class Benz : public Car
{
public:
	//重写纯虚函数
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};
//派生类
class BMV : public Car
{
public:
	//重写纯虚函数
	virtual void Drive() 
	{
		cout << "Audi-高端" << endl;
	}
};
class Audi :public Car
{
public:
	//重写纯虚函数
	virtual void Drive()=0//这里仍然是纯虚函数
	{
		cout << "BMV-操控" << endl;
	}
};
int main()
{
	//派生类重写了纯虚函数，可以实例化出对象
	Benz b1;
	BMV b2;
	//Audi b3;//"Audi" : 无法实例化抽象类	 error

	//不同对象用基类指针调用Drive函数，完成不同的行为
	Car* p1 = &b1;
	Car* p2 = &b2;
	p1->Drive();  //Benz-舒适
	p2->Drive();  //BMV-操控
	return 0;
}

抽象类既然不能实例化出对象，那抽象类存在的意义是什么？

1. 抽象类可以更好的去表示现实世界中，没有实例对象对应的抽象类型，比如：植物、人、动物等这些概念性名词。
2. 抽象类很好的体现了虚函数的继承是一种接口继承，强制子类去重写纯虚函数，因为子类若是不重写从父类继承下来的纯虚函数，那么子类也是抽象类也不能实例化出对象。

2、接口继承和实现继承

实现继承： 普通函数的继承是一种实现继承，派生类继承了基类函数的实现，可以使用该函数。

接口继承： 虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，目的是达成多态，不同对象实现不同函数。

建议： 所以如果不实现多态，就不要把函数定义成虚函数。

2.5【多态的原理】

1、虚函数表

下面是一道常考的笔试题：Base类实例化出对象的大小是多少？

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};
int main()
{
	Base b;
	cout << sizeof(b) << endl; //8
	return 0;
}

通过观察测试，我们发现Base类实例化的对象b的大小是8个字节

这里我们可能会产生疑问，Base中不是就一个int类型的对象吗，为什么大小回事8而不是4呢？

我们可以看到b对象当中除了_b成员外，实际上还有一个_vfptr放在对象的前面（有些平台可能会放到对象的最后面，这个跟平台有关）。

对象中的这个vfptr是一个指针，叫做虚函数表指针（v代表virtual，f代表function)），简称虚表指针，虚表指针指向一个虚函数表，简称虚表，每一个含有虚函数的类中都至少有一个虚表指针。这里这个虚表到底是什么？

我们来看这样一个例子：

下面Base类当中有三个成员函数，其中Func1和Func2是虚函数，Func3是普通成员函数，子类Derive当中仅对父类的Func1函数进行了重写。

class Base
{
public:
	//虚函数
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	//虚函数
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	//普通成员函数
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
//子类
class Derive : public Base
{
public:
	//重写虚函数Func1
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

通过调试可以发现，父类对象b和基类对象d当中除了自己的成员变量之外，父类和子类对象都有一个虚表指针，分别指向属于自己的虚表。

那么什么是虚表呢？虚表之中到底存了什么呢？

实际上虚表当中存储的就是虚函数的地址，因为父类当中的Func1和Func2都是虚函数，所以父类对象b的虚表当中存储的就是虚函数Func1和Func2的地址。而子类继承了父类自然也继承了父类的虚函数Func1和Func2，但是子类对父类的虚函数Func1进行了重写而没有对Func2进行重写，因此，子类对象d的虚表当中存储的是父类的虚函数Func2的地址和重写的Func1的地址。所以我们可以发现子类中Func1的地址与父类中Func1的地址不同：

而造成地址不同的原因就是，虚函数的重写也叫做覆盖，覆盖就是指对虚表中虚函数地址的覆盖，重写是语法的叫法，覆盖是原理层的叫法。

其次需要注意的是：Func2是虚函数，所以继承下来后放进了子类的虚表，而Func3是普通成员函数，继承下来后不会放进子类的虚表。此外，虚函数表本质是一个存虚函数指针的指针数组，一般情况下会在这个数组最后放一个nullptr。

那么到这里我们就知道了虚函数表本质上是一个函数指针数组，数组中存放的是虚函数的地址，子类继承父类虚函数时会先将父类虚函数的地址拷贝到自己的虚函数表里，如果子类对该虚函数进行了重写，该虚函数的地址就会被新生成的地址所覆盖，没进行重写则采用父类对应虚函数的地址。

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

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

虚表是什么阶段初始化的？虚函数存在哪里？虚表存在哪里？

虚表实际上是在构造函数初始化列表阶段进行初始化的，注意虚表当中存的是虚函数的地址不是虚函数，虚函数和普通函数一样，都是存在代码段的，只是他的地址又存到了虚表当中。另外，对象中存的不是虚表而是指向虚表的指针。

至于虚表是存在哪里的，我们可以通过以下这段代码进行判断。

class Base
{
public:
	//虚函数
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	//虚函数
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	//普通成员函数
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
//子类
class Derive : public Base
{
public:
	//重写虚函数Func1
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};

int j = 0;
int main()
{
	Base b;
	Base* p = &b;
	printf("vfptr:%p\n", *((int*)p)); 
	int i = 0;
	printf("栈上地址:%p\n", &i);       
	printf("数据段地址:%p\n", &j);     

	int* k = new int;
	printf("堆上地址:%p\n", k);       
	const char* cp = "hello world";
	printf("代码段地址:%p\n", cp);    
	return 0;
}

代码当中打印了对象b当中的虚表指针，也就是虚表的地址，可以发现虚表地址与代码段的地址非常接近，由此我们可以得出虚表实际上是存在代码段的。

2.【多态的原理】

上面分析了半天，那么多态的原理到底是什么？

下面我们看一个例子：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
//父类
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
	int _p = 1;
};
//子类
class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
	int _s = 2;
};
int main()
{
	Person Mike;
	Student Johnson;
	Johnson._p = 3; //以便观察是否完成切片
	Person* p1 = &Mike;
	Person* p2 = &Johnson;
	p1->BuyTicket(); //买票-全价
	p2->BuyTicket(); //买票-半价
	return 0;
}

上面代码中，为什么当父类Person指针指向的是父类对象Mike时，调用的就是父类的BuyTicket，当父类Person指针指向的是子类对象Johnson时，调用的就是子类的BuyTicket?

上面因为Jhonson中重写了父类的虚函数，则子类中虚函数表中BuyTicket的地址被更新了，因此编译器是直接找到子类虚函数表中对应的虚函数地址进而调用的。

围绕此图分析便可得到多态的原理：

1. 父类指针p1指向Mike对象，p1->BuyTicket在Mike的虚表中找到的虚函数就是Person::BuyTicket。
2. 父类指针p2指向Johnson对象，p2>BuyTicket在Johnson的虚表中找到的虚函数就是Student::BuyTicket。

这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

下面让我们再思考一个问题：

现在想想多态构成的两个条件，一是完成虚函数的重写，二是必须使用父类的指针或者引用去调用虚函数。必须完成虚函数的重写是因为我们需要完成子类虚表当中虚函数地址的覆盖，那为什么必须使用父类的指针或者引用去调用虚函数呢？为什么使用父类对象去调用虚函数达不到多态的效果呢？

首先看一下用指针或者引用是怎么完成多态调用的：

Person* p1 = &Mike;
Person* p2 = &Johnson;

使用父类指针或者引用时，实际上是一种切片行为，切片时只会让父类指针或者引用得到父类对象或子类对象中切出来的那一部分。这点参考父子类之间的对象赋值转换。

因此，我们后序用p1和p2调用虚函数时，p1和p2通过虚表指针找到的虚表是不一样的，最终调用的函数也是不一样的。

而如果我们通过父类对象去赋值再调用就会引起以下情形：

Person P1 = Mike;
Person P2 = Johnson;

使用父类对象时，切片得到部分成员变量后，会调用父类的拷贝构造函数对那部分成员变量进行拷贝构造，那么这里就涉及一个问题，在拷贝的过程中有没有把子类的虚函数表也给拷贝过去？答案实际是不会的，一旦父类对象在切片拷贝子类的过程中拷贝了子类的虚函数表那么对象调用虚函数也可以实现多态，但是这里如果拷贝了子类的虚函数表就会引发一系列问题，我们不妨假设父类在切片拷贝子类的过程中会拷贝子类的虚函数表这个行为发生，那么到底会引发哪些问题呢？

假设我们一开始将P1赋值为Jonson这里拷贝了Jhonson的虚函数表，然后调用虚函数，我们知道编译器会通过P1的虚函数表进行调用虚函数，而此时P1的虚函数表为子类的，如果我们再将P1赋值给父类，此时就不能保证P1的虚函数表也是父类的虚函数表了，这样在P1调用虚函数时就不一定是父类中的虚函数了。

还有一个问题就是析构函数可能也会出问题，可能会出现父类对象调用子类析构函数的问题。

上面说明父对象在切片拷贝子类对象时会拷贝子类对象的虚函数表这个假设是错误的，所以实际的情况是拷贝构造出来的父类对象P1和P2当中的虚表指针指向的都是父类对象的虚表。因为同类型的对象共享一张虚表，他们的虚表指针指向的虚表是一样的。

因此，我们后序用P1和P2调用虚函数时，P1和P2通过虚表指针找到的虚表是一样的，最终调用的函数也是一样的，也就无法构成多态。

这里为什么说同类型的对象共享一张虚表：

说明每个类都有自己的虚函数表，同类对象的虚函数表相同。

总结一下：

1. 构成多态，指向谁就调用谁的虚函数，跟对象有关。
2. 不构成多态，对象类型是什么就调用谁的虚函数，跟类型有关。

3.【动态绑定与静态绑定】

静态绑定： 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也成为静态多态，比如：函数重载。

动态绑定： 动态绑定又称为后期绑定(晚绑定)，在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

我们可以通过查看汇编的方式进一步理解静态绑定和动态绑定：

我们若是按照如下方式调用BuyTicket函数，则不构成多态，函数的调用是在编译时确定的。

int main()
{
	Student Johnson;
	Person p = Johnson; //不构成多态
	p.BuyTicket();
	return 0;
}

将调用函数的那句代码翻译成汇编就只有以下两条汇编指令，也就是直接调用的函数。

而我们若是按照如下方式调用BuyTicket函数，则构成多态，函数的调用是在运行时确定的。

int main()
{
	Student Johnson;
	Person& p = Johnson; //构成多态
	p.BuyTicket();
	return 0;
}

这样就很好的体现了静态绑定是在编译时确定的，而动态绑定是在运行时确定的。也就是说静态绑定是在编译的过程中，由编译器找到对应函数的地址，进而调用即可，而动态调用则是，函数在运行时，虚函数表在构造函数调用时初始化，编译器通过虚函数表来找到对应虚函数调用的。

2.6【单继承和多继承关系的虚函数表】

1、【单继承中的虚函数表】

以下列单继承关系为例，我们来看看基类和派生类的虚表模型。

class Base //父类
{
public:
	virtual void func1() 
	{ 
		cout << "Base::func1" << endl; 
	}
	virtual void func2() 
	{ 
		cout << "Base::func2" << endl; 
	}
private:
	int _a;
};
class Derive :public Base//子类
{
public:
	virtual void func1() 
	{
		cout << "Derive::func1" << endl;
	}
	virtual void func3() 
	{
		cout << "Derive::func3" << endl;
	}
	virtual void func4()
	{
		cout << "Derive::func4" << endl;
	}
private:
	int _b;
};

其中，基类和派生类对象的虚表模型如下：

在单继承关系当中，派生类的虚表生成过程如下：

1. 继承基类的虚表内容到派生类的虚表。
2. 对派生类重写了的虚函数地址进行覆盖，比如func1。
3. 虚表当中新增派生类当中新的虚函数地址，比如func3和func4。

我们可以看到，父类Base中有两个虚函数func1()和func2(),而子类Derive中有三个虚函数，其中仅仅对func1()重写。但是我们通过监视窗口看，却只有两个虚函数，那么是否每个虚函数都存在于虚函数表中呢？

我们可以使用以下代码，打印上述基类和派生类对象的虚表内容，在打印过程中可以顺便用虚函数地址调用对应的虚函数，从而打印出虚函数的函数名，这样可以进一步确定虚表当中存储的是哪一个函数的地址。

class Base //父类
{
public:
	virtual void func1() 
	{ 
		cout << "Base::func1" << endl; 
	}
	virtual void func2() 
	{ 
		cout << "Base::func2" << endl; 
	}
private:
	int _a;
};
class Derive :public Base//子类
{
public:
	virtual void func1() 
	{
		cout << "Derive::func1" << endl;
	}
	virtual void func3() 
	{
		cout << "Derive::func3" << endl;
	}
	virtual void func4()
	{
		cout << "Derive::func4" << endl;
	}
private:
	int _b;
};
typedef void(*VFPTR)(); //虚函数指针类型重命名
//打印虚表地址及其内容
void PrintVFT(VFPTR* ptr)
{
	printf("虚表地址:%p\n", ptr);
	for (int i = 0; ptr[i] != nullptr; i++)//由于vs一般会在虚函数表的末尾放0，所以我们一直取到不为0即可
	{
		printf("ptr[%d]:%p-->", i, ptr[i]); //打印虚表当中的虚函数地址
		ptr[i](); //并使用虚函数地址调用虚函数
	}
	printf("\n");
}
// 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存放虚函数
//指针的指针数组，这个数组最后面放了一个nullptr
// 1.先取b的地址，强转成一个int*的指针，目的是取出虚函数表的地址，大小为4个字节，所以要强转为int
// 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针，此时为整形，再将其转换为函数指针
// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
// 4.虚表指针传递给PrintVTable进行打印虚表
// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
//后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再
//编译就好了。
int main()
{
	Base b;
	PrintVFT((VFPTR*)(*(int*)&b)); //打印基类对象b的虚表地址及其内容
	Derive d;
	PrintVFT((VFPTR*)(*(int*)&d)); //打印派生类对象d的虚表地址及其内容
	return 0;
}

当然我们也可以使用内存监视窗口进行查看，因为内存窗口看到的内容是最真实的，我们调出内存监视窗口，然后输入派生类对象当中的虚表指针，即可看到虚表当中存储的四个虚函数地址。

2.【多继承中的虚函数表】

以下列多继承关系为例，我们来看看基类和派生类的虚表模型

class Base1 //父类1
{
public:
	virtual void func1() 
	{
		cout << "Base1::func1" << endl; 
	}
	virtual void func2() 
	{
		cout << "Base1::func2" << endl;
	}
private:
	int b1;
};
class Base2 //父类2
{
public:
	virtual void func1()
	{
		cout << "Base2::func1" << endl;
	}
	virtual void func2()
	{
		cout << "Base2::func2" << endl; 
	}
private:
	int b2;
};
class Derive : public Base1, public Base2 //子类多继承
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}
	virtual void func3()
	{
		cout << "Derive::func3" << endl;
	}
private:
	int d1;
};
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}

父类对象的虚函数表如下：

子类对象的虚函数表如下：

在多继承关系当中，派生类的虚表生成过程如下：

1. 分别继承各个基类的虚表内容到派生类的各个虚表当中。
2. 对派生类重写了的虚函数地址进行覆盖(派生类中的各个虚表中存有该被重写虚函数地址的都需要进行覆盖)，比如func1。
3. 在派生类第一个继承基类部分的虚表当中新增派生类当中新的虚函数地址，比如func3。

当然这里我们也可以通过内存窗口和打印的方式来观察：

1、内存窗口

2、打印

下面两个父类，Base1和Base2，其中Derive只对func1()，进行了重写，并添加了虚函数func3()。

class Base1 //父类1
{
public:
	virtual void func1() 
	{
		cout << "Base1::func1" << endl; 
	}
	virtual void func2() 
	{
		cout << "Base1::func2" << endl;
	}
private:
	int b1;
};
class Base2 //父类2
{
public:
	virtual void func1()
	{
		cout << "Base2::func1" << endl;
	}
	virtual void func2()
	{
		cout << "Base2::func2" << endl; 
	}
private:
	int b2;
};
class Derive : public Base1, public Base2 //子类多继承
{
public:
	virtual void func1()
	{
		cout << "Derive::func1" << endl;
	}
	virtual void func3()
	{
		cout << "Derive::func3" << endl;
	}
private:
	int d1;
};
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);//找到第一个虚表的地址
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));//VFPTR* vTableb2=VFPTR* vTableb1+1;,跳过一个VFPTR*类型
	PrintVTable(vTableb2);
	return 0;
}

也可采用下面的方式：

typedef void(*VFPTR)(); //虚函数指针类型重命名
//打印虚表地址及其内容
void PrintVFT(VFPTR* ptr)
{
	printf("虚表地址:%p\n", ptr);
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("ptr[%d]:%p-->", i, ptr[i]); //打印虚表当中的虚函数地址
		ptr[i](); //使用虚函数地址调用虚函数
	}
	printf("\n");
}
int main()
{
	Base1 b1;
	Base2 b2;
	PrintVFT((VFPTR*)(*(int*)&b1)); //打印基类对象b1的虚表地址及其内容
	PrintVFT((VFPTR*)(*(int*)&b2)); //打印基类对象b2的虚表地址及其内容
	Derive d;
	PrintVFT((VFPTR*)(*(int*)&d)); //打印派生类对象d的第一个虚表地址及其内容
	PrintVFT((VFPTR*)(*(int*)((char*)&d + sizeof(Base1)))); //打印派生类对象d的第二个虚表地址及其内容
	return 0;
}

2.7【菱形继承、菱形虚拟继承】

这里附上两篇参考资料：

1、C++ 虚函数表解析 | 酷 壳 - CoolShell

2、C++ 对象的内存布局 | 酷 壳 - CoolShell

以下列菱形虚拟继承关系为例，我们来看看基类和派生类的虚表模型。

class A
{
public:
	virtual void funcA()
	{
		cout << "A::funcA()" << endl;
	}
private:
	int _a;
};
class B : virtual public A
{
public:
	virtual void funcA()
	{
		cout << "B::funcA()" << endl;
	}
	virtual void funcB()
	{
		cout << "B::funcB()" << endl;
	}
private:
	int _b;
};
class C : virtual public A
{
public:
	virtual void funcA()
	{
		cout << "C::funcA()" << endl;
	}
	virtual void funcC()
	{
		cout << "C::funcC()" << endl;
	}
private:
	int _c;
};
class D : public B, public C
{
public:
	virtual void funcA()
	{
		cout << "D::funcA()" << endl;
	}
	virtual void funcD()
	{
		cout << "D::funcD()" << endl;
	}
private:
	int _d;
};

继承关系如下：

其中，A类当中有一个虚函数funcA，B类当中有一个虚函数funcB，C类当中有一个虚函数funcC，D类当中有一个虚函数funcD。此外B类、C类和D类当中均对A类当中的funcA进行了重写。

下面让我们看一下各成员内部的分布：

1、A类对象当中的成员及其分布情况：

A类对象的成员包括一个虚表指针和成员变量_a，虚表指针指向的虚表当中存储的是A类虚函数funcA的地址。

2、B类对象当中的成员及其分布情况：

B类由于是虚拟继承的A类，所以B类对象当中将A类继承下来的成员放到了最后，除此之外，B类对象的成员还包括一个虚表指针、一个虚基表指针和成员变量_b，虚表指针指向的虚表当中存储的是B类虚函数funcB的地址。

虚基表当中存储的是两个偏移量，第一个是虚基表指针距离B虚表指针的偏移量，第二个是虚基表指针距离虚基类A的偏移量。

3、C类对象当中的成员及其分布情况：

C类对象当中的成员分布情况与B类对象当中的成员分布情况相同。C类也是虚拟继承的A类，所以C类对象当中将A类继承下来的成员放到了最后，除此之外，C类对象的成员还包括一个虚表指针、一个虚基表指针和成员变量_c，虚表指针指向的虚表当中存储的是C类虚函数funcC的地址。

虚基表当中存储的是两个偏移量，第一个是虚基表指针距离C虚表指针的偏移量，第二个是虚基表指针距离虚基类A的偏移量。

4、D类对象当中的成员及其分布情况：

D类对象当中成员的分布情况较为复杂，D类的继承方式是菱形虚拟继承，在D类对象当中，将A类继承下来的成员放到了最后，除此之外，D类对象的成员还包括从B类继承下来的成员、从C类继承下来的成员和成员变量_d。

需要注意的是，D类对象当中的虚函数funcD的地址是存储到了B类的虚表当中。

5、注意

实际中不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面使用这样的模型访问基类成员有一定的性能损耗。

2.8【继承和多态常见的面试问题】

问答题

1、什么是多态？

多态是指不同继承关系的类对象，去调用同一函数，产生了不同的行为。多态又分为静态的多态和动态的多态。其中一般静态多态称为函数重载，动态多态是父类的指针或引用调用虚函数，虚函数完成重写。

2、什么是重载、重写(覆盖)、重定义(隐藏)？

1、重载是指两个函数在同一作用域，这两个函数的函数名相同，参数不同。

2、重写(覆盖)是指两个函数分别在基类和派生类的作用域，这两个函数的函数名、参数、返回值都必须相同(协变例外)，且这两个函数都是虚函数。

3、重定义(隐藏)是指两个函数分别在基类和派生类的作用域，这两个函数的函数名相同。若两个基类和派生类的同名函数不构成重写就是重定义。

3、多态的实现原理？

构成多态的父类对象和子类对象的成员当中都包含一个虚表指针，这个虚表指针指向一个虚表，虚表当中存储的是该类对应的虚函数地址。因此，当父类指针指向父类对象时，通过父类指针找到虚表指针，然后在虚表当中找到的就是父类当中对应的虚函数；当父类指针指向子类对象时，通过父类指针找到虚表指针，然后在虚表当中找到的就是子类当中对应的虚函数。

4、inline函数可以是虚函数吗？

答案是可以的，我们知道内联函数是会在调用的地方展开的，也就是说内联函数是没有地址，但是内联函数是可以定义成虚函数的，当我们把内联函数定义虚函数后，编译器就忽略了该函数的内联属性，这个函数就不再是内联函数了，因为需要将虚函数的地址放到虚表中去。而如果定义后的内联函数只是被普通调用，该函数仍具有内联属性，而没有虚函数属性。

5、静态成员函数可以是虚函数吗？

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

6、构造函数可以是虚函数吗？

构造函数不能是虚函数，因为对象中的虚表指针是在构造函数初始化列表阶段才初始化的，如果构造函数是虚函数，那么其需要存在于虚表中，导致构造函数无法调用因为它无法初始化。

7、析构函数可以是虚函数吗？什么场景下析构函数是虚函数？

析构函数可以是虚函数，并且最后把基类的析构函数定义成虚函数。若是我们分别new一个父类对象和一个子类对象，并均用父类指针指向它们，当我们使用delete调用析构函数并释放对象空间时，只有当父类的析构函数是虚函数的情况下，才能正确调用父类和子类的析构函数分别对父类和子类对象进行析构，否则当我们使用父类指针delete对象时，只能调用到父类的析构函数。

8、对象访问普通函数快还是虚函数更快？

对象访问普通函数比访问虚函数更快，若我们访问的是一个普通函数，那直接访问就行了，但当我们访问的是虚函数时，我们需要先找到虚表指针，然后在虚表当中找到对应的虚函数，最后才能调用到虚函数。

9、虚函数表是在什么阶段生成的？存在哪的？

虚表是在构造函数初始化列表阶段进行初始化的，虚表一般情况下是存在代码段(常量区)的。

10、C++菱形继承的问题？虚继承的原理？

菱形虚拟继承因为子类对象当中会有两份父类的成员，因此会导致数据冗余和二义性的问题。

虚继承对于相同的虚基类在对象当中只会存储一份，若要访问虚基类的成员需要通过虚基表获取到偏移量，进而找到对应的虚基类成员，从而解决了数据冗余和二义性的问题。

11、什么是抽象类？抽线类的作用？

抽象类很好的体现了虚函数的继承是一种接口继承，强制子类去抽象纯虚函数，因为子类若是不抽象从父类继承下来的纯虚函数，那么子类也是抽象类也不能实例化出对象。其次，抽象类可以很好的去表示现实世界中没有示例对象对应的抽象类型，比如：植物、人、动物等。

---

总结

本篇介绍了C++中的继承和多态，讲述了继承和多态的使用以及继承和多态一些比较偏底层的原理。本篇博客到这里就结束了，感谢观看！

---

............................................................................................你能不能再编一个理由，等我回家

------------《等我回家》