参考：

1. https://blog.csdn.net/weixin_42678507/article/details/89414998  （直接说明原理）

2 .https://www.cnblogs.com/dormant/p/5223215.html   （很多好例子）

3. https://blog.csdn.net/qq_39412582/article/details/81628254  （干货需要慢慢研究）

C++ 多态的定义及实现
1. 多态定义的构成条件
多态是在不同继承关系的类对象，去调同一函数，产生了不同的行为。
就是说，有一对继承关系的两个类，这两个类里面都有一个函数且名字、参数、返回值均相同，然后我们通过调用函数来实现不同类对象完成不同的事件。
但是构成多态还有两个条件：

调用函数的对象必须是指针或者引用。
被调用的函数必须是虚函数，且完成了虚函数的重写。

说了这么多，怎么实现呢？我们先来看一段代码。
#include

class Person
{
public:
    virtual void BuyTicket(int)
    {  
        std::cout << "Adult need Full Fare!" << std::endl;
    }  
};

class Child : public Person
{
public:
    virtual void BuyTicket(int)
    {  
        std::cout << "Child Free!" << std::endl;
    }  
};

void fun(Person& obj)
{
    obj.BuyTicket(1);                                                                                                                            
}

int main(void)
{
    Person p;
    Child c;

fun(p);
    fun(c);

return 0;
}

调用函数就是这里的fun，参数int没有实际意义，就是为了体现函数重写必须要返回值一样、函数名一样和参数一样。
被调用的函数必须是虚函数，也就是说必须要在两个产生多态的函数前面加virtual关键字。
调用函数的形参对象必须是基类对象，这里是因为派生类只能给基类赋值，会发生切片操作。基类不能给派生类赋值。
调用函数的参数必须是指针或引用，因为派生类改变了虚表，那么这个虚表就属于派生类对象，赋值的时候只会把基类的成员给过去，

虚表指针不会给。所以在调用函数的时候会发生语法检查，如果满足多态的条件，就会触发寻找虚表中虚函数地址。

如果不满足条件，则会直接用基类对象调用基类函数。

上面牵扯出两个概念：

虚函数：虚函数就是在类的成员函数前面加virtual关键字。

虚函数重写：虚函数的重写：派生类中有一个跟基类的完全相同虚函数，我们就称子类的虚函数重写了基类的虚函数。
完全相同是指：函数名、参数、返回值都相同。另外虚函数的重写也叫作虚函数的覆盖
虚函数重写有一个例外错误：协变
重写的虚函数的返回值可以不同，但是必须分别是基类指针或引用和派生类指针或引用。
这种情况在VS会报错，但是在linux的G++下不会
#include
 
class A                                                                 
{
public:                                                                 
    virtual A* fun()
    {
        return new A;                                                   
    }
};

class B : public A
{
public:
    virtual B* fun()
    {
        return new B;
    }
};

不规范重写行为：
就是在派生类的重写函数加了virtual关键字，但是在派生类的重写函数前不加。
这样不会报错，因为继承的原因，将这个virtual的性质继承了下来，但是这样写不规范，
如果两个函数构成重写，那么要在两个函数前都加上virtual关键字。
2.析构函数重写问题
基类中的析构函数如果是虚函数，那么派生类的析构函数就重写了基类的析构函数。这里他们的函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，这也说明的基类的析构函数最好写成虚函数。
将析构函数定义为虚函数的原因：
因为基类指针可能指向派生类，当delete的时候，如果不定为虚函数，系统会直接调用基类的析构函数，这个时候派生类就有一部分没有被释放，就会造成可怕的内存泄漏问题。
若定义为虚函数构成多态，那么就会先调用派生类的析构函数然后派生类的析构函数会自动调用基类的析构函数，这个结果满足我们的本意。
所以！在继承的时候，尽量把基类的析构函数定义为虚函数，这样继承下去的派生类的析构函数也会被变成虚函数构成多态。
3.抽象类
在虚函数的后面写上 =0 ，则这个函数就变成纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。
这个纯虚函数的作用就是强迫我们重写虚函数，构成多态。这样更加体现出了接口继承。
#include

class Person
{
public:
    virtual void Strength() = 0;
};

class Adult : public Person
{
public:
    virtual void Strength()
    {  
        std::cout << "Adult have big Strength!" << std::endl;
    }  
};

class Child : public Person
{
public:
    virtual void Strength()
    {  
        std::cout << "Child have Small Strength!" << std::endl;                                                                                  
    }  
};

4.C++11 override 和 final
override:
override是用来检查函数是否重写，是在virtual void fun() override {}这里加上，然后来检查的。实际中，建议这样写。
final:
final是在class A final {};这里加上，目的是为了不让这个类被继承。
或者，在一个函数后加，表示这个函数不能被重写。void fun() final {}。

C++ 多态详解

前几天在网上看到这样的一个问题：

多态现在一般的用法，就是拿一个父类的指针去调用子类中被重写的方法。但我搞不懂为什么要那么做，我们直接在子类中写一个同名的成员函数，从而隐藏父类的函数不就行了么？

然后有人这样回答：

将父类比喻为电脑的外设接口，子类比喻为外设，现在我有移动硬盘、U盘以及MP3，它们3个都是可以作为存储但是也各不相同。如果我在写驱动的时候，我用个父类表示外设接口，然后在子类中重写父类那个读取设备的虚函数，那这样电脑的外设接口只需要一个。但如果我不是这样做，而是用每个子类表示一个外设接口，那么我的电脑就必须有3个接口分别来读取移动硬盘、U盘以及MP3。若以后我还有SD卡读卡器，那我岂不是要将电脑拆了，焊个SD卡读卡器的接口上去？

所以，用父类的指针指向子类，是为了面向接口编程。大家都遵循这个接口，弄成一样的，到哪里都可以用，准确说就是“一个接口，多种实现“。

这个解答很有意思！！！

忽然感觉学了很长时间的C++只是知道有多态这样一个重要的概念，编程时怎么用，却真的没有仔细想一下它的机制，也就是它是怎么实现的。于是看了些资料，做一下总结。

先看一个例子：

执行完之后的结果是这样的：

这个很好理解，但当我们将函数g()加上virtual之后再看结果会看到

变成了4。这是因为在后者中变成了虚函数了。

virtual是让子类与父类之间的同名函数有联系，这就是多态性，实现动态绑定。

任何类若是有虚函数就会比比正常的类大一点，所有有virtual的类的对象里面最头上会自动加上一个隐藏的，不让我知道的指针，它指向一张表，这张表叫做vtable，vtable里是所有virtual函数的地址。

下边来看这样两段代码：

1 class Shape {
2 public:
3 Shape();
4 virtual ~Shape();
5 virtual void render();
6 void move(const pos&);
7 virtual void resize();
8 protected:
9 pos center;
10 };

这个类的内存分布是这样的：

就是在成员变量前有一个vtable的指针，它会指向一个table,这个table叫做虚函数表。

1 class Ellipse : public Shape{
2 public:
3 Ellipse (float majr, float minr);
4 virtual void render();
5
6 protected:
7 float major_axis;
8 float minor_axis;
9
10 };

Ellipse继承与Shape，看一下它的内存分布：

这里的vtable不是对象的，而是属于类的，这就是多态的实现机制。

如果需要了解更多关于虚表的知识，链接：

http://blog.csdn.net/haoel/article/details/1948051/

这样由上面的解释我们来详细讲解一下多态的概念和实现：

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。其实我看到过一句话：调用同名函数却会因上下文的不同而有不同的实现。我觉得这样更加贴切，还加入了多态三要素：（1）相同函数名  （2）依据上下文  （3）实现却不同；

来看这个例子：

1 #include
2 using namespace std;
3
4 class A {
5 public:
6 A() : i(10）{}
7 virtual void f() { cout<< "A::f()"<<i<<endl;}
8
9 int i;
10 };
11
12 class B : public A{
13 public:
14 B() : j(20) {}
15 virtual void f() { cout << "B::f()" << j <<endl;}
16
17 int j;
18 };
19
20 int main()
21 {
22
23 A a;
24 B b;
25 A *p = &b; 26 p->f(); 27 return 0;
28 }

这时我们执行这个程序，b的f()函数会执行，执行结果是"B::f() 20"，这里就是多态中的动态绑定，本来是基类型的指针赋给了子类型的对象地址，这样当运行时才能知道执行哪个f()函数。

之后修改main函数：

1 int main()
2 {
3 A a;
4 B b;
5 A *p = &b;
6 p->f();
7 a = b;
8 a.f();
9 return 0;
10 }

执行结果是：

B::f() 20

A::f() 10

可见a.f()的结果输出是不同的。有很多理由说明这个，其一就是通过指针或引用才是动态绑定，通过点运算是不可以的。

多态特性的工作依赖虚函数的定义，在需要解决多态问题的重载成员函数前，加上virtual关键字，那么该成员函数就变成了虚函数，从上例代码运行的结果看，系统成功的分辨出了对象的真实类型，成功的调用了各自的重载成员函数。

虚函数的定义要遵循以下重要规则： 

**1.如果虚函数在基类与派生类中出现，仅仅是名字相同，而形式参数不同，或者是返回类型不同，那么即使加上了virtual关键字，也是不会进行滞后联编的。 

2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数。 

3.静态成员函数不能是虚函数,因为静态成员函数的特点是不受限制于某个对象。 

4.内联(inline)函数不能是虚函数，因为内联函数不能在运行中动态确定位置。即使虚函数在类的内部定义定义，但是在编译的时候系统仍然将它看做是非内联的。 

5.构造函数不能是虚函数，因为构造的时候，对象还是一片位定型的空间，只有构造完成后，对象才是具体类的实例。 

6.析构函数可以是虚函数,而且通常声名为虚函数。**

同时需要了解多态的特性的virtual修饰，不单单对基类和派生类的普通成员 函数有必要，而且对于基类和派生类的析构函数同样重要！！！

C++ 之 多态（非常非常重要，重点在后面）
           
                                版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。                           
                           
                                本文链接：https://blog.csdn.net/qq_39412582/article/details/81628254
                            
                        
这篇博客有点长，但都是满满的干货，一定要看到最后，那才是重点。
什么是多态？
顾名思义就是同一个事物在不同场景下的多种形态。
 下面会具体的详细的介绍。

静态多态

我们以前说过的函数重载就是一个简单的静态多态

int Add(int left, int right)
{
    return left + right;
}
double Add(double left, int right)
{
    return left + right;
}

int main()
{
    Add(10, 20);
    //Add(10.0, 20.0);  //这是一个问题代码
    Add(10.0,20);  //正常代码
    return 0;
}

可以看出来，静态多态是编译器在编译期间完成的，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数可以调用就调，没有的话就会发出警告或者报错。。。比较简单，不做多介绍。

动态多态

什么是动态多态呢？
动态多态： 显然这和静态多态是一组反义词，它是在程序运行时根据基类的引用（指针）指向的对象来确定自己具体该调用哪一个类的虚函数。
我在西安临潼上学，我就以这边的公交车举个栗子啊：

class TakeBus
{
public:
    void TakeBusToSubway()
    {
        cout << "go to Subway--->please take bus of 318" << endl;     }     void TakeBusToStation()     {         cout << "go to Station--->pelase Take Bus of 306 or 915" << endl;
    }
};
//知道了去哪要做什么车可不行，我们还得知道有没有这个车
class Bus
{
public:
    virtual void TakeBusToSomewhere(TakeBus& tb) = 0;  //？？？为什么要等于0
};

class Subway:public Bus
{
public:
    virtual void TakeBusToSomewhere(TakeBus& tb)
    {
        tb.TakeBusToSubway();
    }
};
class Station :public Bus
{
public:
    virtual void TakeBusToSomewhere(TakeBus& tb)
    {
        tb.TakeBusToStation();
    }
};

int main()
{
    TakeBus tb;
    Bus* b = NULL;
    //假设有十辆公交车，如果是奇数就是去地铁口的，反之就是去火车站的
    for (int i = 1; i <= 10; ++i)     {         if ((rand() % i) & 1)             b = new Subway;         else             b = new Station;     }     b->TakeBusToSomewhere(tb);
    delete b;
    return 0;
}

这就是一个简单的动态多态的例子，它是在程序运行时根据条件去选择调用哪一个函数。
而且，从上面的例子我们还发现了我在每一个函数前都加了virtual这个虚拟关键字，想想为什么？如果不加会不会构成多态呢？
干想不如上机实践：

class Base
{
public:
    virtual void Funtest1(int i)
    {
        cout << "Base::Funtest1()" << endl;
    }
    void Funtest2(int i)
    {
        cout << "Base::Funtest2()" << endl;
    }
};
class Drived :public Base
{
    virtual void Funtest1(int i)
    {
        cout << "Drived::Fubtest1()" << endl;
    }
    virtual void Funtest2(int i)
    {
        cout << "Drived::Fubtest2()" << endl;
    }
    void Funtest2(int i)
    {
        cout << "Drived::Fubtest2()" << endl;
    }
};
void TestVirtual(Base& b)
{
    b.Funtest1(1);
    b.Funtest2(2);
}
int main()
{
    Base b;
    Drived d;
    TestVirtual(b);
    TestVirtual(d);
    return 0;
}

在调用FuncTest2的时候我们看出来他并没有给我们调用派生类的函数，因此我们可以对动态多态的实现做个总结。

动态多态的条件：
●基类中必须包含虚函数，并且派生类中一定要对基类中的虚函数进行重写。
●通过基类对象的指针或者引用调用虚函数。

重写 ：
（a）基类中将被重写的函数必须为虚函数（上面的检测用例已经证实过了）
（b）基类和派生类中虚函数的原型必须保持一致（返回值类型，函数名称以及参数列表），协变和析构函数（基类和派生类的析构函数是不一样的）除外
（c）访问限定符可以不同
那么问题又来了，什么是协变？
协变：基类（或者派生类）的虚函数返回基类（派生类）的指针（引用）
总结一道面试题：那些函数不能定义为虚函数？
经检验下面的几个函数都不能定义为虚函数：
1）友元函数，它不是类的成员函数
2）全局函数
3）静态成员函数，它没有this指针
3）构造函数，拷贝构造函数，以及赋值运算符重载（可以但是一般不建议作为虚函数）

抽象类：
在前面公交车的例子上我提了一个问题：

class Bus
{
public:
    virtual void TakeBusToSomewhere(TakeBus& tb) = 0;  //？？？为什么要等于0
};

在成员函数(必须为虚函数)的形参列表后面写上=0，则成员函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。纯虚函数在派生类中重新定义以后，派生类才能实例化出对象。纯虚函数是一定要被继承的，否则它存在没有任何意义。

多态调用原理

class Base
{
public:
    virtual void Funtest1(int i)
    {
        cout << "Base::Funtest1()" << endl;
    }
    virtual void Funtest2(int i)
    {
        cout << "Base::Funtest2()" << endl;
    }
    int _data;
};

int main()
{
    cout << sizeof(Base) << endl;
    Base b;
    b._data = 10;
    return 0;
}

8？不知道大家有没有问题，反正我是有疑惑了。以前在对象模型（https://blog.csdn.net/qq_39412582/article/details/80808754）时我提到过怎么来求一个类的大小。按照那个方法，这里应该是4才对啊，为什么会是8呢？

通过观察。我们发现这个例子里面和以前不一样，类成员函数变成了虚函数，这是不是引起类大小变化的原因呢？
我们假设就是这样，然后看看内存里是怎么存储的呢？
 
可以看到它在内存里多了四个字节，那这四个字节的内容到底是什么呢？

是不是有点看不懂，我们假设它是一个地址去看地址里存的东西的时候发现它存的是两个地址。
我假设它是虚函数的地址，我们来验证一下：

typedef void (__stdcall *PVFT)();  //函数指针
int main()
{
    cout << sizeof(Base) << endl;
    Base b;
    b._data = 10;
    PVFT* pVFT = (PVFT*)(*((int*)&b));
    while (*pVFT)
    {
        (*pVFT)();
        pVFT+=1;
    }
    return 0;
}

结果好像和我们的猜想一样，是一件开心的事。然后我给一张图总结一下：
 
在反汇编中我们还可以看到，如果含有虚函数的类中没有定义构造函数，编译器会自动合成一个构造函数

对于派生类的东西我给个链接仔细看，人家总结的超级赞，我偷个懒就不写了，老铁们包容下啊。

派生类虚表：
1.先将基类的虚表中的内容拷贝一份
2.如果派生类对基类中的虚函数进行重写，使用派生类的虚函数替换相同偏移量位置的基类虚函数
3.如果派生类中新增加自己的虚函数，按照其在派生类中的声明次序，放在上述虚函数之后
https://coolshell.cn/articles/12176.html

多态缺陷

●降低了程序运行效率（多态需要去找虚表的地址）
●空间浪费