C++多态

1. 多态的概念

多态的概念：通俗来说，是多种形态。具体点就是去完成某个行为，不同的对象去完成时会产生出不同的状态。（举个例子：比如面对考试，学霸胸有成竹，而学渣是祈求老天）

2. 多态的定义及实现

2.1 多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student类继承了Person类。（Person对象买票全价，Student对象买票半价。）

那么在继承中要构成多态还有两个条件：
$1.$必须通过基类的指针或者引用调用虚函数
$2.$被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

2.2 虚函数

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

class Pet
{
public:
	virtual void Bark()
	{
		cout << _name << "在叫" << endl;
	}
protected:
	string _name;
};

// 编译报错：因为func不是成员函数
virtual void func()
{}

2.3 虚函数的重写

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

class Pet
{
public:
	Pet(const string& name, const string& gender, int age)
		: _name(name)
		, _gender(gender)
		, _age(age)
	{}


	virtual void Bark()
	{
		cout << _name << "在叫" << endl;
	}

protected:
	string _name;
	string _gender;
	int _age;
};

class PetDog : public Pet
{
public:
	PetDog(const string& name, const string& gender, int age, const string& color)
		: Pet(name, gender, age)
		, _color(color)
	{}
/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后
基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用*/
	void Bark()
	{
		cout << _name << ":旺旺旺~~~" << endl;
	}

protected:
	string _color;
};

2.3.1 虚函数重写的两个例外

$1.协变$(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。$即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变$
$这里的“返回基类对象”可以是别的基类对象，返回派生类对象也是如此（下面的类AA和BB）$

class AA
{};

class BB : public AA
{};

class B
{
public:
	// 与子类中f1关系：重定义
	void f1(){
		cout << "B::f1()" << endl;
	}

	// 与子类中f2关系：重写
	virtual void f2(){
		cout << "B::f2()" << endl;
	}

	// 与子类中f3关系：重写
	virtual void f3(){
		cout << "B::f3()" << endl;
	}

	// 与子类中f4关系：重定义
	void f4(){
		cout << "B::f4()" << endl;
	}

	// 与子类中f5关系：重定义---函数参数列表不同
	virtual void f5(){
		cout << "B::f5()" << endl;
	}

	virtual void f6(){
		cout << "B::f6()" << endl;
	}

	// 与子类中f7关系：重写--->协变
	virtual B* f7(){
		cout << "B::f7()" << endl;
		return this;
	}
	//返回其它基类的引用
	virtual AA& f8(){
		cout << "B::f8()" << endl;
		return a;
	}
	//重写与访问权限无关
	virtual void f9(){
		cout << "B::f9()" << endl;
	}
};

class D : public B
{
public:
	void f1(){
		cout << "D::f1()" << endl;
	}

	virtual void f2(){
		cout << "D::f2()" << endl;
	}

	void f3(){
		cout << "D::f3()" << endl;
	}

	virtual void f4(){
		cout << "D::f4()" << endl;
	}

	// 与基类中f5参数列表不同
	virtual void f5(int){
		cout << "D::f5(int)" << endl;
	}

	// 编译报错：因为基类和子类虚函数返回值类型不同
	// 而且不是协变
	//virtual int f6()
	//{
	//	cout << "D::f6()" << endl;
	//	return 0;
	//}
	virtual D* f7()override{
		cout << "D::f7()" << endl;
		return this;
	}
	//返回其它子类的引用
	virtual BB& f8()override{
		cout << "D::f8()" << endl;
		return b;
	}
	
	//重写与访问权限无关
private:
	virtual void f9(){
		cout << "D::f9()" << endl;
	}
};

$2.析构函数的重写$(基类与派生类析构函数的名字不同)
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写。这里可以理解为编译器对析构函数的名称做了特殊处理。

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

class D : public B
{
public:
	virtual ~D() {
		cout << "D::~D()" << endl;
	}
};

// 只有派生类 D的析构函数重写了 B的析构函数，下面的delete对象调用析构函数，才能构成多态，
// 才能保证指向的对象正确调用析构函数。
int main()
{

	B* pb = new B();
	delete pb;

	pb = new D();
	delete pb;
	pb = nullptr;
	return 0;
}

2.4 C++11 override 和 final

2.4.1 override

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

class A 
{
public:
    virtual void AA(){}
};

class B :public A 
{
public:
	virtual void AA() override 
	{
	cout << "AABB" << endl;
	}
};

2.4.2 final

final：修饰虚函数，表示该虚函数不能再被重写

// 实现一个类，不能被继承
// final修饰类，表明该类不能被继承
class String final
{
public:
	String(const char* str = "")
	{
		if (nullptr == str)
			str = "";

		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}
private:
	char* _str;
};

class A : public String
{};

// final: 可以修改成员函数
// 注意： 只能修饰虚函数, 该虚函数不能被其子类重写
//       只修饰子类的虚函数
class B
{
public:
	virtual void f1()
	{
		cout << "B::f1()" << endl;
	}

	// 语法可以通过，但是没有意义
	// 因为将基类的成员函数设置为虚函数，目的就是为了实现多态
	// 在其子类中必须要对基类的虚函数进行重写
	virtual void f2()final
	{
		cout << "B::f2()" << endl;
	}
};

class D : public B
{
public:
	//“final”函数必须是虚函数	
	//void f0()final
	//{}

	virtual void f1()final
	{
		cout << "D::f1()" << endl;
	}

	//无法重写“final”函数 "B::f2" 
	//virtual void f2()
	//{
	//	cout << "D::f2()" << endl;
	//}
};

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

3. 抽象类

3.1 概念

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

// 抽象类：将包含纯虚函数的类
class Pet
{
public:
	Pet(const string& name, const string& gender, int age)
		: _name(name)
		, _gender(gender)
		, _age(age)
	{}

	// 纯虚函数
	virtual void Bark() = 0;
	virtual void Eat() = 0;

protected:
	string _name;
	string _gender;
	int _age;
};

const double PI = 3.14;

// 抽象类
class Shape
{
public:
	// 纯虚函数
	virtual double GetArea() = 0;
	virtual double GetPerimeter() = 0
	{
		cout << "Shape::GetPerimeter()" << endl;
	}
};

// 子类一定要对基类中的 所有 纯虚函数进行重写
// 否则子类也是抽象类
class Circle : public Shape
{
public:
	Circle(double r)
		: _r(r)
	{}

	virtual double GetArea()
	{
		return PI * _r * _r;
	}

	virtual double GetPerimeter()
	{
		return 2 * PI * _r;
	}

protected:
	double _r;
};


class Rect : public Shape
{
public:
	Rect(double length, double width)
		: _length(length)
		, _width(width)
	{}

	virtual double GetArea()
	{
		return _length * _width;
	}

	virtual double GetPerimeter()
	{
		return 2 * (_length + _width);
	}

protected:
	double _length;
	double _width;
};

void TestShape(Shape* ps)
{
	cout << ps->GetArea() << endl;
	cout << ps->GetPerimeter() << endl;
}

int main()
{
	// 抽象类不能实例化对象
	//Shape shape;
	
	Circle circle(2.0);
	Rect rect(1.0, 2.0);
	TestShape(&circle);
	TestShape(&rect);
	return 0;
}

3.2 接口继承和实现继承

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

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

4.多态的原理

4.1 虚函数表

// 这里：sizeof(Base)是多少？
class Base
{
public:
	virtual void Func1()
{
	cout << "Func1()" << endl;
}
private:
	int _b = 100;
};

通过观察测试我们发现b对象是8字节，除了_b成员，还多一个__vfptr放在对象的前面，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。那么派生类中这个表放了些什么呢？

针对上面的代码我们做出以下改造
1.我们增加一个派生类Derive去继承Base
2.Derive中重写虚函数Func1
3.Base再增加一个虚函数Func2和一个普通函数Func3

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

class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
	
	/*virtual void Func4()
	{
		cout << "Derive::Func4()" << endl;
	}*/
private:
	int _d = 2;
};

int main()
{
	Base b;
	Derive d;
	return 0;
}

子类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，另一部分是自己的成员

通过上图我们可以发现基类Base和子类Derive的虚表指针不同，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。

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

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

$子类的虚表生成：$
a.先将基类中的虚表内容拷贝一份到子类虚表中
b.如果子类重写了基类中某个虚函数，用子类自己的虚函数覆盖虚表中基类的虚函数
c.子类自己新增加的虚函数按其在子类中的声明次序增加到子类虚表的最后
(新增加一个func4可以看出，如下图：)

在 00ca1370 后面就是新增加的虚函数func4的地址

虚函数存在哪的？虚表存在哪的？
答：虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的。对象中存的是虚表指针,那么虚表存在哪的呢？去验证会发现vs下是存在代码段的。

4.2 多态的原理

$1.观察下图的橙色箭头我们看到，b引用基类对象时，b.Func1()在基类的虚表中找到虚函数是Base::Func1()$
$2.观察下图的紫色箭头我们看到，b引用子类对象时，b.Func1()在子类的虚表中找到虚函数是Derive::Func1()$

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

4.3 动态绑定与静态绑定

通过上面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用是在编译时确认好的。

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

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

5.单继承和多继承关系的虚函数表

5.1 单继承中的虚函数表

class B
{
public:
	B(int b = 0)
		: _b(b)
	{}

	virtual void f1()
	{
		cout << "B::f1()" << endl;
	}

	virtual void f2()
	{
		cout << "B::f2()" << endl;
	}

	virtual void f3()
	{
		cout << "B::f3()" << endl;
	}

	int _b;
};

class D : public B
{
public:
	virtual void f4()
	{
		cout << "D::f4()" << endl;
	}

	virtual void f1()
	{
		cout << "D::f1()" << endl;
	}

	virtual void f3()
	{
		cout << "D::f3()" << endl;
	}

	virtual void f5()
	{
		cout << "D::f5()" << endl;
	}
	int _d;
};



// pfun是函数指针变量，只能指向：返回值类型是void，没有参数的一些列函数

void (*pfun)();

// 加了typedef之后，PVFT就是类型
typedef void(*PVFT)();  //相当于typedef void(*)()  PVFT; 


void PrintVFT(B& b, const string& info)
{
	cout << info << endl;
	// 1. 先要拿到虚表的地址---通过对象模型已经知道虚表的地址在对象前4个字节
	//int value = *(int*)&b;

	PVFT* pvft = (PVFT*)*(int*)&b;
	while (*pvft)
	//虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr
	{
		(*pvft)();
		pvft++;
	}
}

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

	B  b;
	PrintVFT(b, "B VFT:");

	cout << "==============" << endl;

	D d;
	PrintVFT(d, "D VFT:");

	return 0;
}

运行结果：

$子类的虚表生成：$
a.先将基类中的虚表内容拷贝一份到子类虚表中
b.如果子类重写了基类中某个虚函数，用子类自己的虚函数覆盖虚表中基类的虚函数
c.子类自己新增加的虚函数按其在子类中的声明次序增加到子类虚表的最后

一个类的多个对象共用一个张虚表

5.2 多继承中的虚函数表

class B1
{
public:
	virtual void f1()
	{
		cout << "B1::f1()" << endl;
	}

	virtual void f2()
	{
		cout << "B1::f2()" << endl;
	}

	int _b1;
};


class B2
{
public:
	virtual void f3()
	{
		cout << "B2::f3()" << endl;
	}

	virtual void f4()
	{
		cout << "B2::f4()" << endl;
	}

	int _b2;
};


class D : public B1, public B2
{
public:
	virtual void f1()
	{
		cout << "D::f1()" << endl;
	}

	virtual void f4()
	{
		cout << "D::f4()" << endl;
	}

	virtual void f5()
	{
		cout << "D::f5()" << endl;
	}

	int _d;
};


typedef void(*PVFT) ();

void PrintB1OfDVFT(B1& b, const string& info)
{
	cout << info << endl;
	PVFT* pvft = (PVFT*)*(int*)&b;
	while (*pvft)
	{
		(*pvft)();
		++pvft;
	}
}

void PrintB2OfDVFT(B2& b, const string& info)
{
	cout << info << endl;
	PVFT* pvft = (PVFT*)*(int*)&b;
	while (*pvft)
	{
		(*pvft)();
		++pvft;
	}
}

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

	D d;
	d._b1 = 1;
	d._b2 = 2;
	d._d = 3;

	PrintB1OfDVFT(d, "B1 of D VFT:");
	cout << "========" << endl;
	PrintB2OfDVFT(d, "B2 of D VFT:");
	return 0;
}

运行结果：

观察下图可以看出：多继承中子类的未重写的虚函数放在第一个继承基类部分的虚函数表中

6.虚函数与一般函数比较

class B
{
public:
	void f0()
	{
		cout << "B::f0()" << endl;
	}

	virtual void f1()
	{
		cout << "B::f1()" << endl;
	}

	virtual void f2()
	{
		cout << "B::f2()" << endl;
	}

	virtual void f3()
	{
		cout << "B::f3()" << endl;
	}

	int _b;
};

class D : public B
{
public:
	void f0()
	{
		cout << "D::f0()" << endl;
	}

	virtual void f1()
	{
		cout << "D::f1()" << endl;
	}

	virtual void f3()
	{
		cout << "D::f3()" << endl;
	}
	int _d;
};

void TestVirtual1(B* pb)
{
	pb->f0();    // call  B::f0(0x??????h)

	pb->f1();
	pb->f2();
	pb->f3();
}

void TestVirtual2(B b)
{
	b.f0();
	b.f1();
	b.f2();
	b.f3();
}

int main()
{
	B b;
	TestVirtual1(&b);
	cout << "============" << endl;

	D d;
	TestVirtual1(&d);
	cout << "============" << endl;
	TestVirtual2(b);
	cout << "============" << endl;
	TestVirtual2(d);
	return 0;
}

运行结果：

$区别：$

$调用虚函数：$

$调用普通函数：$

7.反思

1.多态的实现原理？

2.inline函数可以是虚函数吗？
答：语法上可以这样写。编译器会在调用内联函数的地方展开，没有函数压栈的开销，所以也没有函数的入口地址；而编写虚函数就是为了实现多态，把虚函数的地址放到虚表中去，内联函数没有函数入口地址。此时如果内联函数作为虚函数，就无法实现多态，那么它作为虚函数的意义就不大了。

3.静态成员可以是虚函数吗？
答：不能。静态成员函数与具体对象无关，属于整个类，核心关键是没有隐藏的this指针，可以通过类名::成员函数名 直接调用，此时没有this无法拿到虚表，就无法实现多态，因此不能设置为虚函数

4.构造函数可以是虚函数吗？
答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

5.析构函数可以是虚函数吗？
答：可以，并且最好把基类的析构函数定义成虚函数。

6.对象访问普通函数快还是虚函数更快？
答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快。因为构成多态时，调用虚函数需要到虚函数表中去查找。

7.虚函数表是在什么阶段生成的？
答：虚函数表是在编译阶段就生成的。

8.虚函数表和虚基表?