C++ 之 多态（很是很是重要，重点在后面）

编译环境：WIN10 VS2017 
这篇博客有点长，但都是满满的干货，必定要看到最后，那才是重点。 
什么是多态？ 
顾名思义就是同一个事物在不一样场景下的多种形态。 
 
下面会具体的详细的介绍。

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

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

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

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
这就是一个简单的动态多态的例子，它是在程序运行时根据条件去选择调用哪个函数。 
并且，从上面的例子咱们还发现了我在每个函数前都加了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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
在调用FuncTest2的时候咱们看出来他并无给咱们调用派生类的函数，所以咱们能够对动态多态的实现作个总结。

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

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

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

class Bus
{
public:
    virtual void TakeBusToSomewhere(TakeBus& tb) = 0;  //？？？为何要等于0
};
1
2
3
4
5
在成员函数(必须为虚函数)的形参列表后面写上=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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
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
4
5
6
7
8
9
10
11
12
13
14
 
结果好像和咱们的猜测同样，是一件开心的事。而后我给一张图总结一下： 

在反汇编中咱们还能够看到，若是含有虚函数的类中没有定义构造函数，编译器会自动合成一个构造函数 

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

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