C++多态

概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生不同的状态。
举个例子：当普通人去买票时，是全价购票，学生买票，是半价购票，军人买票则是优先买票。

多态的定义及实现

多态的构成条件

多态是在不同继承关系的类对象去调用同意函数，产生了不同行为。继承中构成多态还有两个条件：
1.必须通过基类的指针或者引用调用虚函数
2.被调用的函数必须是虚函数，且派生类必须对基类的函数进行重写

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

class Student : public Person
{
public:
	// 子类中三同（函数名、参数、返回值）虚函数，叫做重写（覆盖）
	// 重写要求返回值相同有一个例外：协变--要求返回值是父子关系的指针或者引用
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};

// 构成多态，传的哪个类型的对象，调用的就是这个类型的虚函数 -- 跟对象有关
// 不构成多态，调用的就是p类型的函数， -- 跟类型有关

void Func(Person& p)
{
	p.BuyTicket();
}

函数重写的两个例外

1.协变（基类与派生类虚函数的返回值类型不同）

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

class A {};
class B : public A {};

class Person
{
public:
	virtual A* f()
	{
		return new A;
	}
};

class Student : public Person
{
public:
	virtual B* f()
	{
		return new B;
	}
};

2.析构函数的重写

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数不同，看起来违背了重写规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

// 析构函数是虚函数，构成重写
// 析构函数名被特殊处理了，处理成了destructor

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

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

	// 虚函数的重写允许，两个都是虚函数或者父类是虚函数，在满足三同，就收构成重写。
	// 建议两个都写上virtual
	// 虽然子类没写virtual，但是他先继承了父类虚函数的属性，再完成重写
	// 本质上，子类重写的虚函数可以不加virtual是因为析构函数
	// 设计初衷是父类析构函数加上virtual，那么就不存在不构成多态，没调用子类析构函数，内存泄露
};

override和final

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

final

修饰虚函数，表示虚函数不能被重写

class C
{
public:
	virtual void f() final
	{
		cout << "C" << endl;
	}
};
class D : public C
{
	virtual void f()
	{
		cout << "D" << endl;
	}
	// 此时f不能被重写
};

用final获取一个不能被继承的类

在C++98中要获取一个不能被继承的类需要把基类的构造函数置为私有。

class A
{
private:
	A (int a = 0)
		: _a(a)
	{}
public:
	static A createOBJ(int a = 0)
	{
		return A(a);
	}
	// 因为将构造函数设为私有后将无法直接
	// 实例化基类对象，所以写一个函数来实
	// 例化对象
protected:
	int _a;
};

class B : public A
{};

在C++11中操作变得更加简单，只需要在基类后面加上final就行。

class A final
{
public:
	A (int a)
		: _a(a)
	{}
protected:
	int _a;
};

class B : public A
{

};

override

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

class player
{
public:
	virtual void f()
	{}
};

class messi : public player
{
public:
	virtual void f() override
	{
		cout << "messi" << endl;
	}
};

重载、覆盖（重写）、隐藏（重定义）的对比

重载：

• 1.两个函数在同一作用域
• 2.函数名相同，参数不同
  重写
• 1.两个函数分别在基类和派生类的作用域
• 2.函数名、参数、返回值都必须相同（协变除外）
• 3.两个函数必须是虚函数
  重定义：
• 1.两个函数分别在基类和派生类的作用域
• 2.函数名相同
• 3.两个基类和派生类的同名函数不构成重写就是重定义

抽象类

概念

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

class player
{
public:
	virtual void func() = 0;
	// 纯虚函数一般只声明，不实现
	// 实现没有价值，因为含有纯虚函数的类
	// 不能实例化出对象
};

class messi : public player
{
	virtual void func();
};

// 纯虚函数的类，本质上是强迫子类去完成虚函数的重写
// 纯虚函数体现了接口继承

接口继承和实现继承

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

多态的原理

先来想个问题，这个类的有多大？

class player
{
public:
	virtual void f1()
	{
		cout << "f1" << endl;
	}
private:
	int _a = 1;
};

答案是8，在类里除了_a成员之外还有一个还多一个_vfptr放在对象前面，对象中的这个指针我们叫作虚函数表指针（v代表virtual，f代表function）。一个含有虚函数的类中至少有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也称为虚表。那么派生类中这个表放了些什么呢？

将上面的代码做这样的改造
1.增加一个派生类去继承player类
2.在新类中重写f1
3.基类再增加一个虚函数f2()和一个普通函数f3

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

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

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

private:
	int _a = 1;
};

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

private:
	int _m = 30;
};

int main()
{
	player p1;
	messi m;

	return 0;
}

我们会发现一下几点问题
1.派生类对象m中也有一个虚表指针，m对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员
2.基类p1对象和派生类m对象的虚表是不一样的，我们发现f1完成了重写，所以m的虚表中存的是重写的messi::f1，所以虚函数的重写也叫覆盖，覆盖就是虚表中虚函数的覆盖。重写是语法的叫法，覆盖是底层原理的叫法。
3.另外f2继承下来后是虚函数，所以放进了虚表，f3也继承下来了，但是不是虚函数，所以不会被放进虚表。
4.虚函数表本质是一个存虚函数指针的指针数组，一般情况下这个数组的最后放了一个nullptr。
5.派生类虚函数表的生成：
a.先将基类中的虚表内容拷贝一份到派生类虚表中
b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数。
c.派生类自己新增加的虚函数按其在派生类中声明的次序增加到派生类虚表的最后。
6.这里还有一个容易混淆的问题：虚函数是存在哪的？虚表是存在哪的？要注意虚表存的是虚函数的指针，不是虚函数，虚函数和普通函数一样存在代码段中，只是它的指针有存到了虚表中。另外对象中存的是虚表指针，不是虚表，而虚表存在代码段中。

动态绑定与静态绑定

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