C++——多态

1、多态的定义及实现

2、抽象类

3、多态的原理

4、单继承和多继承关系中的虚函数表

---

1、多态的定义及实现

多态的定义：多态是在不同继承关系的类对象去调用同一函数产生了不同的行为。

构成多态的两个条件：

a、必须通过基类的指针或引用调用虚函数

b、被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

1.1虚函数

虚函数：被vitural修饰的类成员函数

class Person{

public：

        vitural void BuyTicket()        { cout << "买票—全价" << endl; }

};

1.2虚函数的重写

虚函数的重写：派生类中有一个跟基类完全相同的虚函数（函数名、参数、返回值都相同）

class Person{

public：

        vitural void BuyTicket()        { cout << "买票—全价" << endl; }

};

class Student : public Person {

public:

        virtual void BuyTicket()        { cout << "买票—半价" << endl; }

};

虚函数重写的两个例外：

a、协变（基类与派生类函数返回值类型不同）

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

b、析构函数的重写（基类与派生类析构函数的名字不同）

如果基类的析构函数为虚函数，那么派生类析构函数只要定义就与基类析构函数构成重写，这里的析构函数虽然函数名不同但仍构成重写的原因是编译器对析构函数的名称作了特殊处理，统一处理成了destructor。

1.3C++11 override和final

a、override：夹在子类虚函数声明的后面来检查是否完成重写，如果没有会报错

class Person{

public：

        vitural void BuyTicket()        { cout << "买票—全价" << endl; }

};

class Student : public Person {

public:

        virtual void BuyTicket()     override   { cout << "买票—半价" << endl; }

};

b、final：修饰虚函数，表示该虚函数不能再被重写

class Person{

public：

        vitural void BuyTicket()     final   { cout << "买票—全价" << endl; }

};

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

重载：两个函数在同一作用域，函数名/参数相同

重写（覆盖）：两个函数分别在基类和派生类的作用域，函数名/参数/返回值都必须相同，两个函数必须是虚函数

重定义（隐藏）：两个函数分别在基类和派生类的作用域，函数名相同，只要不构成重写就是重定义

---

2、抽象类

在虚函数的后面写上 =0，这个函数就为纯虚函数，包含纯虚函数的类就是抽象类（接口类），抽象类不能实例化对象。

class Person{

public：

        vitural void BuyTicket()  = 0；      

};

class Student : public Person {

public:

        virtual void BuyTicket()        { cout << "买票—半价" << endl; }

};

class Teacher : public Person {

public:

        virtual void BuyTicket()        { cout << "买票—全价" << endl; }

};

---

3、多态的原理

3.1虚函数表

//一道常见笔试题：sizeof(Base)是多少？

class Base

{

public:

        virtual void Func1()

        {

                cout << "Func1()" << endl;

        }

private:

        int _b = 1;

};

可以注意到，这里除了_b成员，还多了一个_vfptr放在对象的前面，这个指针就是虚函数指针，一个含有虚函数的类中至少都有一个虚函数指针，因为虚函数的地址要被放到虚函数表中（虚表）。

class Base

{

public:

        virtual void Func1()

        {

                cout << "Func1()" << endl;

        }

        virtual void Func2()

        {

                cout << "Base::Func2" << endl;

        }

        void Func3()

        {

                cout << "Base::Func()" << endl;

        }

private:

        int _b = 1;

};

class Derive : public Base

{

public:

        virtual void Func1()

        {

                cout << "Derive::Func1()" << endl;

        }

private:

        int _d = 2;

};

从上面调试窗口可以看出，派生类Derive继承下来的是基类的_b成员和虚表中的Func2函数，而Func1函数在派生类完成了重写所以将基类继承下来的Func1覆盖，而Func3函数则不是虚函数，被继承下来了但没有进虚表。

3.2多态的原理 

class Person{

public：

        vitural void BuyTicket()        { cout << "买票—全价" << endl; }

};

class Student : public Person {

public:

        virtual void BuyTicket()        { cout << "买票—半价" << endl; }

};

void Func(Person& people)

{

        people.BuyTicket();

}

void Test()

{

        Person Mike;

        Func(Mike);

        Student Johnson;

        Func(Johnson);

}

 

 当p是指向mike对象时，p->BuyTicket在mike的需表中找到的虚函数是Person::BuyTicket,同理，当p指向johnson对象时，p->BuyTicket在johnson的虚表中找到虚函数时Student::BuyTicket。这样就实现了不同对象去完成同一行为时，展现出不同的状态。

而多态函数的调用，是运行起来以后到对象中取找的，不满足多态函数调用是编译时确认好的。

---

4、单继承和多继承关系中的虚函数表

4.1单继承中的虚函数表

class Base {

public :

virtual void func1 () { cout << "Base::func1" << endl ;}

virtual void func2 () { cout << "Base::func2" << endl ;}

private :

int a ;

};

class Derive : public Base {

public :

virtual void func1 () { cout << "Derive::func1" << endl ;}

virtual void func3 () { cout << "Derive::func3" << endl ;}

virtual void func4 () { cout << "Derive::func4" << endl ;}

private :

int b ;

};

派生类的虚表从基类复制一份，如果有重写的就覆盖，有新的虚函数就添加进去。

4.2多继承中的虚表

#include <iostream>
using namespace std;

class Base1 {
public:
    virtual void func1() { cout << "Base1::func1" << endl; }
    virtual void func2() { cout << "Base1::func2" << endl; }
private:
    int b1;
};
class Base2 {
public:
    virtual void func1() { cout << "Base2::func1" << endl; }
    virtual void func2() { cout << "Base2::func2" << endl; }
private:
    int b2;
};
class Derive : public Base1, public Base2 {
public:
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func3" << endl; }
private:
    int d1;
};
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
    cout << " 虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i)
    {
        printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
        VFPTR f = vTable[i];
        f();
    }
    cout << endl;
}
int main()
{
    Derive d;
    VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    PrintVTable(vTableb1);
    VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
    PrintVTable(vTableb2);
    return 0;
}

多继承中派生类未重写的虚函数放在第一个继承基类部分的虚函数表中。