多态（虚函数表，抽象类，虚表，虚函数的重写，final，override关键字）

1.多态的概念

1.1概念
多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。（就比如成人与小孩乘车时车票的售价，有成人票，和儿童票。）
2.多态的定义及实现
多态定义的构成条件：多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。
那么在继承中要构成多态还有两个条件：

1. 调用函数的对象必须是指针或者引用。
2. 被调用的函数必须是虚函数，且完成了虚函数的重写。
   那么问题来了，什么是虚函数？其实很简单，只需要在成员函数前加上virtual 关键字就构成了虚函数。

class Person
{
	public：
	Virtual void BuyTicket()
	{	
		cout<<"购买全价票"<<endl;
		}
}；

2.2.1什么是虚函数重写？
虚函数的重写：派生类中有一个跟基类的完全相同虚函数，我们就称子类的虚函数重写了基类的虚函数，完全相同是指：函数名、参数、返回值都相同。另外虚函数的重写也叫作虚函数的覆盖。

class A
{
		public:
		virtual void print()
		{cout<<"ha ha"<<endl;}

};
class B :public A
{
	public:
	virtual void print()
	{cout<<"he he"<<endl;}
};

void Func(A& a)	//调用对象的引用
{
	a.print();	//调用的是虚函数
}
int main()
{
	A a;
	B b;
	Func(a);
	Func(b);
	return 0;
}

2.2.2虚函数重写的例外：协变
虚函数重写有一个例外：重写的虚函数的返回值可以不同，但是必须分别是基类指针和派生类指针或者基类 引用和派生类引用。协变了解一下就可以了，这个用得很少。
下面就是协变的一个例子：

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

class Person
{
public:
virtual A* func()	//虚函数的返回值不同，但是返回的是基类的指针
{return new A;}
};

class Student :public Person
{
public:
	virtual B* func()	//返回派生类的指针
	{return new B;}
};

2.2.3不规范的重写行为
在派生类中重写的成员函数可以不加virtual关键字，也是构成重写的，因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性，我们只是重写了它。但是这是非常不规范的，我们平时不要这样使用。

class A
{
	public:
	virtual void func()
	{cout<<"haha"<<endl;}
};
class B :public A
{
	public:
	void func()
	{cout<<"hehe"<<endl;}
};

2.2.3析构函数的重写问题
基类中的析构函数如果是虚函数，那么派生类的析构函数就重写了基类的析构函数。这里他们的函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，这也说明的基类的析构函数最好写成虚函数。

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

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

	// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。 
	int main()
	{
		Person* p1 = new Person;
		Person* p2 = new Student;
		delete p1;
		delete p2;
		system("pause");
		return 0;
	}

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

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

3.抽象类

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

class A
{
	public:
	virtual void print()=0;
};
class B:public A
{
	public:
	virtual void print()
	{cout<<"I am B"<<endl;}
};
class C:public A
{
	public:
	virtual void print()
	{cout<<"I am C"<<endl;}
};
void Test()
{
	A* PB=new B;
	PB->print();
	A* PC=new C;
	PC->print();
}
int main()
{
Test();
	return 0;
}

那么抽象类有什么作用吗？
看下面的例子你会对抽象类有正确的理解：
抽象类的一个功能–不能被实例化。也就是不能被new.
举个生活中的例子
宠物类下面有狗狗类，猫猫类来继承它。
一般的情况我们有这两种方法
宠物类 a =new 狗狗类();
翻译就是。我有一只宠物，这只宠物是狗狗，它叫a
狗狗类a=new 狗狗类();
我有一只狗狗，它叫a.
这个不区别。关键的是，楼主来看下面的代码
宠物类 a=new 宠物类();
虽然我们经常说，我有一只宠物。（但是请注意，实际上没有一种叫宠物有东西。宠物是个泛泛的概念，我们现实生活中有狗和猫）
所以抽象类不能被new的功能。是为了符合事实意义。
同时也是类的一种高度概括。
我们说类是对象的抽象。抽象类又是各种各校类的抽象。

4.C++11 关键字final和override

这两个关键字是C++11提供数的。
final 关键字在之前的博客里我有提到过，它是用来修饰一个虚函数使该虚函数不能被重写。

class A
{
	public:
	virtual void print() final
	{
		cout<<"haha"<<endl;
	}
};
class B :public A
{
	public:
	virtual void print()
	{
		cout<<"hehe"<<endl;
	}
};

运行结果：

override：

class A
{
public:
 virtual void print()
{ cout<<"haha"<<endl;}
}；

//overirrde 修饰派生类虚函数强制完成重写，如果没有重写会编译报错。
class B
{
	public:
	virtual void pp() override
	{
		cout<<"hehe"<<endl;
	}
};

可以看出，当派生类中用overirrde修饰的函数与基类中的虚函数不构成重写时报错，这里是通过不同。的函数名来使其不能构成重写。只需要将派生类中的虚函数与基类中虚函数构成重写，就不会报错。

5.多态的原理

5.1虚函数表

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

通过观察测试我们发现b对象是8bytes，除了_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 = 1;
};

class Derive :public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;

	system("pause");
	return 0;
}

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

1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就 是存在部分的另一部分是自己的成员。
2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重 写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的 叫法，覆盖是原理层的叫法。
3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会 放进虚表。
4. 虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
5. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基 类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在 派生类中的声明次序增加到派生类虚表的最后。
6. 这里还有一个童鞋们很容易混淆的问题：虚函数存在哪的？虚表存在哪的？
   答：虚函数存在虚表，虚表存在对象中。注意上面的回答是错的。但是很多童鞋都是这样深以为然的。注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外 对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的，Linux g++下大家自己去验证？
   5.2多态的原理
   上面分析了这个半天了那么多态的原理到底是什么？还记得这里print函数传A调用的 A::print，传B调用的是B::print

class A
{
public:
	virtual void print()
	{
		cout << "ha ha" << endl;
	}

};
class B :public A
{
public:
	virtual void print()
	{
		cout << "he he" << endl;
	}
};

void Func(A* p)	//调用对象的引用
{
	p->print();	//调用的是虚函数
}
int main()
{
	A a;
	B b;
	Func(&a);
	Func(&b);
	system("pause");
	return 0;
}

1.观察下图的红色箭头我们看到，p是指向a对象时，p->print在a的虚表中找到虚函数是 A::print。
2. 观察下图的蓝色箭头我们看到，p是指向b对象时，p->print在johson的虚表中找到虚函数 是B::print。
3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。 反思一下为什么？
5. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到 对象的中取找的。不满足多态的函数调用时编译时确认好的

5.3 动态绑定与静态绑定
1.静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
常见问题：
（1） inline函数可以是虚函数吗？答：不能，因为inline函数没有地址，无法把地址放到虚函数表中。
（2）静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
（3）构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
（4）析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析构函数定义 成虚函数。
（5）对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是 引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
（6） 虚函数表是在什么阶段生成的，存在哪的？答：虚函数是在编译阶段就生成的，一般情况下存在代码段 (常量区)的。
（7） C++菱形继承的问题？虚继承的原理？答：参考前面我写的的继承博客。注意这里不要把虚函数表和虚基表搞混了。
（8）什么是抽象类？抽象类的作用？
. 答：参考（3.抽象类）。抽象类强制重写了虚函数，另外抽象类体现出 了接口继承关系。

给大家推荐两个链接帮助大家更好的理解：
虚函数表：
https://coolshell.cn/articles/12165.html
对象的内存布局：
https://coolshell.cn/articles/12176.html
关于多态，就总结了这些，有不合适的地方我们可以互关交流，谢谢大家·。