多态详解（Linux）

一、多态的概念

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

多态又分为静态多态和动态多态：
        (1)静态多态，也称为静态绑定或前期绑定(早绑定)：函数重载和函数模板实例化出多个函数（本质也是函数重载）。静态多态也称为编译期间的多态，编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型转换)，可推断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错误。

        (2)动态多态，也称为动态绑定或后期绑定(晚绑定)：在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，即运行时的多态。在程序执行期间(非编译期)判断所引用对象的实际类型，根据其实际类型调用相应的方法。

为什么动态多态无法在编译时就确定：

        在编译的时候编译器并不知道用户选择的是哪种类型的对象。如果不是虚函数,则采用静态绑定,函数体与函数调用在程序运行之前（编译期间）就绑定了。
        当函数声明为虚函数时,如果使用指针或引用的形式，那么由于指针指向的对象不确定是基类还是派生类，那么编译器就无法采用静态绑定，所以就只有通过动态绑定的方式。因此编译器通过创建一个虚函数表存放虚函数的地址,在运行时,编译器通过虚函数指针在虚函数表中找到正确的函数版本，然后调用。

        总结起来就是：不同的类型对象，去完成同一件事情，产生的动作是不一样的。
        比如抢红包的动作是一样的，但是每个人抢到的金额的大小是不同的，或者买票的时候，做的是同一个事情(买票)、但是不同的人去买票的价格是不一样的、普通乘客去买票是全价、学生去买票是半价，这些就是所谓的多态。

1.1. 多态的构成条件

        多态时滞不同继承关系的类对象，去调用同一函数，产生了不同的行为。在继承中要想构成多态需要满足两个条件：

1.必须通过基类的指针或者引用调用虚函数。

2.被调用的函数必须是虚函数，且派生类必须对积累的虚函数进行重写。

二、虚函数

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

class A
{
  public：
    virtual void Print(){cout << "A::Print()" << endl; }
};

注意：

1.只有类的非静态成员函数前可以加virtual，普通函数（非成员函数），静态成员函数，内联成员函数，构造函数，友元函数不可以加virtual。

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

2.1虚函数的重写

        虚函数的重写也叫做虚函数的覆盖，若派生类中有一个和基类完全相同的虚函数（返回值类型，函数名，参数列表）简称三同，此时我们称该派生类的虚函数重写了基类的虚函数。

        现在我们就可以通过基类的指针或者引用调用虚函数，此时不同类型的对象，调用的就是不同的函数，产生的也是不同的结果，进而实现了函数调用的多种形态。

总结起来就是：调用哪个函数的虚函数，取决于基类指针指向或引用的对象是哪种类型的对象。

#include<iostream>
using namespace std;
class A
{
public:
    virtual void Print() { cout << "A::Print" << endl; }
};

// 继承A类
class B : public A
{
public:
    virtual void Print() { cout << "B::Print" << endl; }
};
// 继承B类
class C : public B
{
    virtual void Print() { cout << "C::Print" << endl; }
};
// 继承A类
class D : public A
{
public:
    virtual void Print() { cout << "D::Print" << endl; }
};
void Func(A& p)
{
    //通过父类的引用调用虚函数
    p.Print();
}
int main()
{
    A a; B b; C c; D d;

    A* pa = &a;
    B* pb = &b;
    D* pd = &d;
    C* pc = &c;

    //通过父类的指针调用虚函数
    pa->Print();  // a.Print()被调用，输出：A::Print
    pa = pb;
    pa->Print(); // b.Print()被调用，输出：B::Print
    pa = pc;
    pa->Print(); // c.Print()被调用，输出：C::Print
    pa = pd;
    pa->Print(); // d.Print()被调用，输出：D::Print

    //通过父类的引用调用虚函数
    Func(a);// a.Print()被调用，输出：A::Print
    Func(b);// b.Print()被调用，输出：B::Print
    Func(c);// c.Print()被调用，输出：C::Print
    Func(d); // d.Print()被调用，输出：D::Print

    return 0;
}

如果不使用基类的指针或引用去调用虚函数，则只会调用基类的虚函数。

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

注意：
虚函数重写只是重写函数的实现，继承的是父类的接口定义（声明），不会重写函数的缺省参数：

2.2虚函数重写的例外

1.协变

父类与子类虚函数返回值类型不同

虚函数要求返回值类型相同、函数名相同以及参数列表完全相同，但是协变是个例外，子类重写基类虚函数时，与基类虚函数返回值类型可以不同。但是返回值类型也必须满足父子关系。

如果不满足则会报错：

2.析构函数的重写

        如果基类的析构函数为虚函数，此时子类的析构函数只要定义，无论是否添加virtual关键字，都与基类的析构函数构成重写。

        虽然基类与派生类析构函数名字不同，但是编译器对析构函数的名字进行了特殊的处理，基类和派生类的析构函数构成隐藏。编译后析构函数的名称同一处理成destructor()，其目的是为了实现析构函数的多态。

        这也就导致了一个问题，基类与派生类的析构函数名字相同，那指向派生类的基类指针调用的就是基类的析构函数：

        由于没有调用派生类的析构函数，派生类如果开辟了资源就会没有释放，最终导致内存泄漏的问题，为了解决这个问题需要把析构函数写为虚函数：

        所以，为了不出现内存泄漏的问题，基类的析构函数要加virtual，由于派生类的虚函数不加virtual关键字也可以构成重写，这样在delete就能够实现多态的正确调用析构函数。

三、C++11override和final

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

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

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

五、抽象类

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

实现继承： 普通函数的继承是一种实现继承，派生类继承了基类函数的实现，可以使用该函数。
接口继承： 虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态。

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

5.1抽象类的意义

        通俗一点的将，抽象类就是不能用来具体描述某一种对象，没有对应的实体 ：比如一个抽象类叫做"植物"，这个植物就是一个抽象类，没有具体对应的实体，如果重写这个类，比如重写这个植物是蒲公英，就有了对应的实体。

六、多态的实现原理

「多态」的关键在于通过基类指针或引用调用一个虚函数时，
编译时不能确定到底调用的是基类还是派生类的函数，运行时才能确定。

6.1虚函数表

class A
{
public:
    int i;
    virtual void Print() { } // 虚函数
};

class B
{
public:
    int n;
    void Print() { }
};

int main()
{
    A a;
    B b;
    cout << sizeof(a) << "," << sizeof(b);
    return 0;
}

        A对象当中除了i成员外，实际上还有一个指针_vfptr放在对象的前面（有些平台可能会放到对象的最后面，这个跟平台有关）

        

#include <iostream>
using namespace std;
//父类
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;
}

        对象中的这个指针叫做虚函数表指针，简称虚表指针，虚表指针指向一个虚函数表，简称虚表，每一个含有虚函数的类中都至少有一个虚表指针。

        虚表当中存储的就是虚函数的地址，因为父类当中的Func1和Func2都是虚函数，所以父类对象b的虚表当中存储的就是虚函数Func1和Func2的地址。

         而子类虽然继承了父类的虚函数Func1和Func2，但是子类对父类的虚函数Func1进行了重写，因此，子类对象d的虚表当中存储的是父类的虚函数Func2的地址和重写的Func1的地址。这就是为什么虚函数的重写也叫做覆盖，覆盖就是指虚表中虚函数地址的覆盖，重写是语法的叫法，覆盖是原理层的叫法。

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

虚表存在哪里？

虚表是什么阶段初始化的？

1.虚表指针在构造函数阶段（初始化列表）填入到对象中，虚表则是在编译时就生成好了。
2.虚表里面放的是虚函数地址，虚函数和普通函数一样，编译完成以后，都是放在代码段中。
3.一个类中所有的虚函数，都会放在虚表中。
4.子类会将父类的虚表拷贝一份，然后用重写的虚函数地址覆盖掉原来虚表中的函数地址，因此虚函数的重写，也叫虚函数的覆盖。

7.2. 虚表如何实现多态

八、多继承的虚函数表

单继承虚函数表：

多继承：

        多继承下，子类所继承的父类不止一个，子类中会存在多个虚函数表，重写虚函数，则会更新对应的虚函数表，若是增加了新的虚函数，则在第一个虚函数表后增加虚函数地址。

class A {

public:
	A(int a = 0, int b = 0) :
		A_a(a), A_b(b)
	{

	}
	virtual void A1() { std::cout << "A::A1" << std::endl; }
	virtual void A2() { std::cout << "A::A2" << std::endl; }

private:
	int A_a;
	int A_b;
};

class B
{
public:
	B(int a = 0) :
		B_a(a)
	{

	}

	virtual void B1() { std::cout << "B::B1" << std::endl; }
	virtual void B2() { std::cout << "B::B2" << std::endl; }

private:
	int B_a;
};

class C : public A, public B
{
public:
	C(int a = 0, int b = 0, int c = 0, int d = 0) :
		A(a, b), B(c), C_a(d)
	{

	}

	virtual void A1() { std::cout << "C::A1" << std::endl; }
	virtual void B1() { std::cout << "C::B1" << std::endl; }
	virtual void C1() { std::cout << "C::C1" << std::endl; }

private:
	int C_a;
};

        从编译器可以看出，类C继承了类A与类B的虚函数表，并且在内存中的顺序是按照继承顺序来的，类C重写的虚函数分别替换了两个父类的虚函数。类C自己新定义的虚函数C1（）则是在继承的第一张虚函数表后添加。类C的具体内存布局如下：

九、多态面试问题

1.inline可以是虚函数吗？
    可以。inline需要展开，编译时不存在地址，但是虚函数需要将其地址存入虚表中，表现上来说，两者是互斥的。但是需要注意，inline只是一个建议性关键字，关键取决于编译器，不会强制性执行。两者关键字存在的时候，如果是多态调用，编译器会自动忽略inline这个建议，因为没法将这个虚函数直接展开，这个建议无了。不是多态就可以利用此建议。
2.static函数可以是虚函数吗？
    不可以。静态成员函数没有this指针，直接利用类域指定的方式调用。虚函数都是为多态服务的。多态是运行时决议，而静态成员函数都是编译性决议。
3.构造函数可以是虚函数吗？
    不可以。构造函数之前，虚表没有进行初始化。virtual函数是为了实现多态，运行时去虚表找对应虚函数进行调用。对象的虚表也是在构造函数的初始化列表进行初始化的。
4.析构函数可以是虚函数。
5.拷贝构造和赋值可不可以是虚函数？
    拷贝构造不可以，拷贝构造同样也是构造函数。
    赋值可以，但是没有意义。
        （但是可以简单实现一下父类给给子  ... ... ）但是，赋值一般是同类对象之间数据进行拷贝，这样就不存在实际价值。
6.对象访问普通函数快还是虚函数快？
    不构成多态一样快，否则普通函数快。
7.虚函数表是在什么阶段生成的，存在哪里的？
    构造函数初始化列表初始化的是虚函数表指针，对象中也是存的指针。
    存在代码区--利用验证法，和只读常量或者静态变量的地址进行验证。