【C++】十一、多态

一、多态的概念

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

//多种形态
//1.静态的多态：函数重载,看起来调用同一个函数有不同行为，静态：编译时实现；
//2.动态的多态：一个父类对象的引用或指针取调用同一个函数，会调用不同的函数，运行时实现；
//本质：不同的人做同一件事，结果不同；
class Person 
{
public:
    virtual void BuyTicket()
    {
        cout << "买票--全价" << endl;
    }
};

class Student : public Person
{
public:
    virtual void BuyTicket()
    {
        //子类中满足三同（函数名、参数、返回值）虚函数，叫做重写（覆盖）
        cout << "买票--半价" << endl;
    }
};

void Func(Person& p)
{
    p.BuyTicket();//此函数实现动态多态，
}

int main()
{

    int i = 1;
    double d = 2.22;
    //静态的多态：函数重载
    cout << i;//cout.operator<<(int)
    cout << d;//cout.operator<<(double)

    //动态
    Person ps;
    Student st;

    Func(ps);
    Func(st);//可以切片过去，所以也可以传子类对象
    return 0;
}

注：例如支付宝扫红包，不同的用户扫出的红包面额不同；

二、多态的定义及实现

多态的构成条件
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。

那么在继承中要构成多态还有两个条件：
1. 必须通过基类的指针或者引用调用虚函数；
（构成多态，传的是那个类型的对象，调用的就是这个类型的虚函数 -- 跟对象有关）
（不构成多态，调用的就是p类型的函数 -- 跟类型有关）
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

虚函数
即被virtual修饰的类的非静态成员函数称为虚函数，其它函数不能成为虚函数；

虚函数的重写
派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

虚函数重写的两个例外：
1. 协变(基类与派生类虚函数返回值类型不同)：派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

2. 析构函数的重写(基类与派生类析构函数的名字不同)：如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

//析构函数是虚函数，也构成重写
//析构函数名被特殊处理了，处理成了destructor
class Person
{
public:
    virtual ~Person() { cout << "~Person()" << endl; }
};

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

int main()
{
    //析构函数是否是虚函数，是否完成重写，都正确调用；
    Person p;
    Student s;

    //动态申请的对象，如果给了父类指针管理，那么需要析构函数是虚函数
    Person* p1 = new Person;//operator new + 构造函数
    Person* p2 = new Student;

    //析构函数 + operator delete
    //         p1->destructor()
    delete p1;
    delete p2;
    //         p2->destructor()
    return 0;
}

C++11 override 和 final
final
修饰虚函数，表示该虚函数不能再被重写

//设计一个不能被继承的类
//C++98
class A
{
private:
    A(int a = 0)
        :_a(a)
    {}

public:
    static A CreateOBj(int a = 0)
    {
        return A(a);
    }

protected:
    int _a;
};

//间接限制，子类构造函数无法调用父类构造函数初始化成员，没办法实例化对象；
class B :public A
{

};

int main()
{
    A aa = A::CreateOBj(10);
    return 0;
}

//C++11
class A final
{

protected:
    int _a;
};

//直接限制
class B :public A
{

};

class C
{
public:
    virtual void f() final
    {
        cout << "C::f()" << endl;
    }
};

class D : public C
{
public:
    virtual void f()
    {
        cout << "D::f()" << endl;
    }
};

int main()
{

    return 0;
}

两个作用，限制类不能被继承，限制函数不能被重写；

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

class Car {
public:
    virtual void Drive() {}
};

class Benz :public Car {
public:
    virtual void Drive() override
    {
        cout << "Benz-舒适" << endl;
    }
};

int mian()
{
    return 0;
}

注：
override放在子类重写的虚函数后面，检查是否完成重写，没有完成重写就会报错

重载、覆盖(重写)、隐藏(重定义)的对比

三、抽象类

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

class Car
{
public:
    //纯虚函数
    virtual void Drive() = 0;
};
class Car
{
public:
    virtual void Drive() = 0;
};

class Benz :public Car
{
public:
    virtual void Drive()
    {
        cout << "Benz-舒适" << endl;
    }
};

class BMW :public Car
{
public:
    virtual void Drive()
    {
        cout << "BMW-操控" << endl;
    }
};
void Test()
{
    Car* pBenz = new Benz;
    pBenz->Drive();
    Car* pBMW = new BMW;
    pBMW->Drive();
}

注：
a、纯虚函数一般只声明不实现，实现没有价值
b、一个类型，如果在一般现实世界中，没有具体的对应实物就定义成抽象类比较好；
c、当计算对象大小时，如果类中有虚函数，则加4字节，（虚函数表指针）；

四、多态的原理

虚函数表

//sizeof(Base)是多少？
class Base
{
public:
   virtual void Func1()
   {
       cout << "Func1()" << endl;
   }
private:
   int _b = 1;
};

实例化出的b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表

多态的原理