C++多态

kjl167

已于 2024-09-10 21:57:34 修改

阅读量683

点赞数 15

分类专栏： C++ 文章标签： c++

于 2024-08-13 23:07:42 首次发布

本文链接：https://blog.csdn.net/kjl167/article/details/141169170

版权

C++ 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、多态基础

1.1 静态编联与动态编联

class Shape 
{
public:
    void show() const {
        cout << "area: " << get_area() << endl;
    }

    float get_area() const { return 0; }
};

class Rectangle : public Shape 
{
public:
    Rectangle(float w, float h)
            : _width(w), _height(h) {}

    float get_area() const { return _width * _height; }

private:
    float _width;
    float _height;
};

class Circle : public Shape {
public:
    Circle(float r) : _radius(r) {}

    float get_area() const { return _radius * _radius * 3.14; }

private:
    float _radius;
};

int main() 
{
    Rectangle rect(1, 2);
    Circle cir(1);
    Shape &sp1 = rect;
    Shape &sp2 = cir;
    sp1.show(); // 输出0
    sp2.show(); // 输出0

    return 0;
}

运行上面代码发现，矩形和圆求出的面积都为0，与我们预期不符合，这是为什么呢，原因在于使用静态编联。

静态编联(早绑定，静态绑定) ：编译期间就决定了具体调用哪个函数体，即使没有主程序，也知道程序中各个函数体之间的调用关系。

/*
	这段代码采用的是静态编联，使用sp1调用show函数，show函数体内调用了get_area成员函数，
	调用非静态成员函数时编译器会传入隐藏this指针，因为this是指向Shape，
	所以调用Shape::get_area函数而不是Rectangle::get_area函数
*/
Shape &sp1 = rect;
sp1.show();】

动态编联（晚绑定，动态绑定）：在运行期间决定具体调用哪个函数体。动态编联有多种实现方式，大多数编译器使用(虚函数和虚函数表）。

1.2 多态

使用基类的指针或引用调用同一方法时，产生不同的行为，这是一种动态多态，大多数C++编译器通过虚函数实现。下文中提到的多态如没有单独说明，则都是指通过虚函数实现的动态多态。

多态构成必须满足下面两个条件：

必须通过基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写(override)

1.3 虚函数

被virtual修饰的类非静态成员函数就是虚函数。

class A
{
public:
	virtual void f(){}; //这是一个虚函数
};

虚函数说明:
• 静态成员函数、构造函数、拷贝构造函数不能是虚函数
• 析构函数可以是虚函数
• 赋值函数通常不定义为虚函数
• 访问控制可以任意（public、protected、private ）

1.4 虚函数重写(override)

虚函数重写(override)：派生类中有一个跟基类完全相同的虚函数(函数名、返回值类、参数列表相同)。

说明：派生类中virtual关键字可以不写，但不推荐。

class Shape
{
public:
    void show() const
    {
        cout << "area: " << get_area() << endl;
    }

    virtual float get_area() const { return 0; }
};

class Rectangle : public Shape
{
public:
    Rectangle(float w, float h)
            : _width(w), _height(h) {}

    float get_area() const { return _width * _height; } // 没写virtual

private:
    float _width;
    float _height;
};

class Circle : public Shape
{
public:
    Circle(float r) : _radius(r) {}

    float get_area() const { return _radius * _radius * 3.14; } // 没写virtual

private:
    float _radius;
};

int main()
{
    Rectangle rect(1, 2);
    Circle cir(1);
    Shape &sp1 = rect;
    Shape &sp2 = cir;
    sp1.show(); // 输出 2
    sp2.show(); // 输出 3.14

    return 0;
}

在实际开发过程中，基类与派生类可能不是同一个人写的，如果基类是虚函数，而派生类忘记写virtual关键字没构成多态可能带来一些不可预料问题。因此，基类是虚函数的情况下,派生类不强制需要写virtual关键字，具有一定安全作用。

1.4.1 虚函数重写两个例外

虚函数重写有两个例外，一个是协变，一个是析构函数的重写，这两种也构成虚函数重写。

协变：派生类中重写（override）基类方法时，返回类型可以是基类方法返回类型(类型必须为指针或引用)的派生类。协变可以使代码更加灵活。

实现协变需满足以下条件：

基类中的函数必须是虚函数
派生类中重写的函数必须具有相同的函数签名（函数名、参数列表和常量性）。
派生类中重写的函数的返回类型必须是基类函数返回类型的派生类型。

class Base 
{
public:
    virtual Base &test() 
    {
        cout << "Base" << endl;
        return *this;
    }
};

class Derived : public Base 
{
public:
    virtual Derived &test() // 协变
    {
        cout << "Derived" << endl;
        return *this;
    }
};

int main() {
    Derived b;
    Base &ref = b;
    ref.test(); // 输出 "Derived"

    return 0;
}

前文中提到析构函数是可以为虚函数的，尤其是存在继承关系的时候，建议将基类析构函数定义为虚函数。

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

class Derived : public Base 
{
public:
    ~Derived() { cout << "~Derived()" << endl; }
};

int main() {
    Base *p = new Derived;
    delete p; 

    return 0;
}

输出：

~Base()

调用delete p时，我们本意根据指针(引用)指向的对象类型来选择对应的析构函数，但结果是根据指针(引用)的类型的来选择对应的析构函数，导致对象没有正确的析构，存在资源泄漏。有人立马想到可以将基类析构函数定义为虚函数解决这个问题，但是重写条件之一是函数名要相同。基类析构函数与派生类析构函数名明显不相同，编译器为了支持析构函数能为虚函数，对析构函数名做了特殊处理，编译后析构函数的名统一处理成destructor。

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

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

int main() 
{
    Base *p = new Derived;
    delete p;

    return 0;
}

输出

~Derived()
~Base()

通过将基类析构函数定义为虚函数，解决继承体系中析构问题。

1.5 override和final关键字

1.5.1 override

override关键字用于显式地声明一个派生类中的虚函数重写了基类中的虚函数。它的主要作用是提高代码的可读性和安全性，确保派生类的函数确实覆盖了基类中的虚函数。

使用override的好处：

避免拼写错误：如果你在派生类中希望重写基类的一个虚函数，但不小心拼写错误或者参数列表不匹配，编译器会报错，提示你并没有成功重写基类的函数。
明确意图：通过在派生类的函数后面加上 override，明确表示你的意图是要重写基类中的虚函数，这有助于代码的可读性。

class Base 
{
public:
    virtual void display() const 
    {
        std::cout << "Base display" << std::endl;
    }
};

class Derived : public Base
{
public:
    void display(int) const override // 使用override关键字
    {  
        std::cout << "Derived display" << std::endl;
    }
};

int main() 
{
    Base *basePtr = new Derived();
    basePtr->display();  // 调用的是 Derived 类中的 display() 方法
    delete basePtr;
    
    return 0;
}

编译时报错：non-virtual member function marked ‘override’ hides virtual member function

1.5.2 final

final关键字用于两个主要场景：1. 防止类被继承，如果在类声明中使用 final，则表示该类不能被进一步继承。2. 防止虚函数被重写，如果在类的虚函数声明后使用 final，则表示该虚函数不能在派生类中被重写。

class Base final {};

class Derived : public Base {}; // 编译报错，Base类不能被继承



class Base 
{
public:
    virtual void display() const final 
    {
        std::cout << "Base display" << std::endl;
    }
};

class Derived : public Base {
public:
    // 下面这段代码将会导致编译错误，因为 display() 函数是 final
    void display() const override 
    {
        std::cout << "Derived display" << std::endl;
    }
};

二、多态原理

2.1 虚函数表指针与虚函数表

虚函数表指针(虚表指针，vfptr)：如果一个类有虚函数，这个类创建的对象中会增加一个指针，指向该对象所属类的虚函数表。在调用虚函数时，程序通过该虚函数表指针（vfptr）找到对应的虚函数表（vtable），再根据虚函数表中的条目找到并调用具体的虚函数实现。

说明：

C++的编译器为了性能会将虚表指针存在于对象最前面的位置，通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的虚函数，在多层继承或是多重继承的情况下，具有极高性能。
单一继承下对象只有一个虚表指针，多重继承/虚拟继承情况下对象会有多个虚表指针。

虚函数表(虚表，vtable)：一个指针数组，存放对应虚函数地址。当一个类定义了虚函数时，编译器为该类生成一个虚表，其中每个条目对应一个虚函数地址。

说明：

虚表在编译期间生成，编译期间虚函数的地址已经存在。
对象中虚表指针是在构造函数的初始化列表中完成赋值的。
同一类所有对象共享一个虚表。
继承中派生类会拷贝一份基类的虚表，如果派生类重写了某个虚函数，则用派生类虚函数地址覆盖虚表中基类函数地址。
派生类新增的虚函数按声明顺序尾插在虚表中。
派生类对象赋值给基类对象时不会拷贝虚表指针，赋值后基类对象虚表指针还是指向基类。
MSVC编译器会存放nullptr作为虚表中最后一个元素，方便虚表遍历，其它编译器不一定存放。
单一继承下一个类只有一个虚表，多重继承/虚拟继承情况下一个类会有多个虚表。

class Base 
{
public:
    virtual ~Base() {}

    void F() {}

    virtual void G() {}

protected:
    virtual void K() {}

    int _a;
};

class Derived: public Base
{
public:
    virtual ~Derived() {}

    void B() {}

    virtual void G() {}
    
    virtual void H() {}

    int _b;
};

在这里插入图片描述

2.2 函数调用的编译

一个对象（变量）的静态类型就是其声明类型，在编译期间就可以确定。一个对象（变量）动态类型就是指程序执行过程中对象（指针或引用）实际所指对象的类型，只有在运行时才能确定。

class Base{};
class Derived:public Base{};

 
Derived derived; // derived的静态与动态类型都为Derived
Base * p = &derived；// p的静态类型为Base*，动态类型Derived*
Base * ref = derived；// p的静态类型为Base&，动态类型Derived&

以编译p->f()为例子

确定p的静态类型Base*
在Base类中，寻找名字为f，且参数可以匹配的函数
若找不到，编译错误
若找到，判断函数是否为virtual函数
a) 不是虚函数，编译为Base::f(p)
b) 是虚函数，编译为(*p->vfptr)[index]((void*)p, ...)

从上面步骤可以看到，若希望p->f()或 ref.f()合法，p/ref的静态类型中必须有匹配的函数f，即使匹配的f永远不被调用。

// Base与Derived类定义参考2.1章节

Base* p1 = new Base;
p1->F(); // 编译为 Base::F(p1)
p1->G(); // 编译为 (*p1->vfptr)[1]((void*)p1)
p1->K(); // 编译错误，K为protected，不能在类外调用
p1->H(); // 编译错误，p1的静态类型为Base*，Base类中没有H函数

Base* p2 = new Derived;
p2->G();  // 编译为 (*p2->vfptr)[1]((void*)p2)
p2->K(); // 编译错误，K为protected，不能在类外调用
p2->H(); // 编译错误，p1的静态类型为Base*，Base类中没有H函数

delete p2; // 编译为 (*p2->vfptr)[0]((void*)p2)
delete p1; // 编译为 (*p1->vfptr)[0]((void*)p1)

2.3 虚函数的访问

在某个函数中调用另外一个函数规则如下：

虚函数中访问的非虚函数：静态编联，使用本地版本
非虚函数中访问的虚函数：动态编联
虚函数中访问的虚函数：动态编联
构造函数不能为虚函数，在构造中调用虚函数采用静态编联，使用本地版本
析构函数可以为虚函数，在析构中调用虚函数采用静态编联，使用本地版本

构造函数不能为虚函数原因：虚函数是为了依据不同的对象来产生不同的状态，但是前提是得有这个对象，而对象的产生必须依靠构造函数；其次，对象中虚表指针的初始化是在构造函数的初始化列表阶段，二者矛盾了。

在构造中调用虚函数采用静态编联原因：对象的构造顺序是先基类，后派生类。假设在基类的构造中调用一个虚函数使用动态编联，派生类重写了该虚函数，这个虚函数使用了派生类的数据。此时派生类还没有构造，结果将是不可预料的。

在析构中调用虚函数采用静态编联原因：对象的析构顺序是先派生类，后基类。假设在基类的析构中调用一个虚函数使用动态编联，派生类重写了该虚函数，这个虚函数使用了派生类的数据。此时派生类资源已经析构，结果将是不可预料的。

class Base 
{
public:
    Base() { vf(); };

    virtual ~Base() { vf(); }

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

    virtual void vg() 
    {
        cout << "Base::vg()" << endl;
        vf();
        nvh();
    }

    void nvh() 
    {
        cout << "Base::nvh()" << endl;
        vf();
    }
};

class Derived : public Base 
{
public:
    Derived() { vf(); }

    virtual ~Derived() { vf(); };

    virtual void vf() { cout << "Derived::vf()" << endl; }

    void nvh() 
    {
        cout << "Derived::nvh()" << endl;
        vf();
    }

    virtual void nj() { cout << "Derived::vn()" << endl; }
};

int main() 
{
    Base *p = new Derived;
    p->vf();
    p->vg();
//  p->nj(); 取消注释会编译错误，p的静态类型为Base*,Base类中没有nj函数
    delete p;
}

输出

Base::vf()
Derived::vf()
Derived::vf()
Base::vg()
Derived::vf()
Base::nvh()
Derived::vf()
Derived::vf()
Base::vf()

Base *p = new Derived;
调用派生类的构造函数，派生类构造函数初始化列表阶段会调用基类的构造函数。基类构造函数调用vf虚函数，在构造中调用虚函数采用静态编联，即调用的基类的vf虚函数，输出Base::vf()。基类构造完后继续派生类构造，派生类构造调用vf虚函数采用静态编联，即调用的派生类的vf虚函数，输出Derived::vf()。

p->vf();
p的静态类型为Base*，Base类中有vf函数，vf为虚函数采用动态编联，p的动态类型为Derived*。调用派生类的vf虚函数，输出Derived::vf()。

p->vg();
p的静态类型为Base*，Base类中有vg函数，vg为虚函数采用动态编联，但是派生类没有重写vg，调用基类的vg函数，先输出"Base::vg()"。vg虚函数中继续调用vf虚函数采用动态编联，即调用派生类vf虚函数，输出"Derived::vf()"。vg虚函数中继续调用nvh函数，nvh不是虚函数采用静态编联，因为vg为基类函数，所以调用基类的nvh函数，先输出Base::nvh()，nvh函数调用vf虚函数采用动态编联，即调用派生类vf虚函数，输出"Derived::vf()"。

delete p;
p的静态类型为Base*，Base类中析构函数为虚函数采用动态编联，调用派生类的析构函数，派生类析构函数调用vf虚函数，在析构中调用虚函数采用静态编联，所以调用的派生类的vf虚函数，输出Derived::vf()。派生类析构函数运行结束前编译器自动会调用基类析构函数，基类析构函数调用vf虚函数，在析构中调用虚函数采用静态编联，所以调用的基类的vf虚函数，输出Base::vf()。

2.4 对象内存布局

在含有虚函数的继承中对象内存布局较为复杂，我水平有限不能将其讲解的很清楚。推荐陈皓大佬两篇文章，相信看完后会对多态有更深的理解，也是对陈皓大佬最好的缅怀。
C++ 虚函数表解析
 C++ 对象的内存布局

三、多态进阶

3.1 静态多态和动态多态

上文中提到的多态是指通过虚函数实现的动态多态，多态分为静态多态和动态多态。
多态性：相同的函数调用，执行不同的代码体，从而有不同的行为后果。

3.1.1 静态多态

静态多态：在编译时根据目标对象的静态类型和参数列表中参数的静态类型确定目标代码体，通过模版与函数重载实现。

模板：允许函数或类根据不同的类型进行实例化，从而在编译时确定具体的实现。

#include <iostream>
#include <typeinfo>

using namespace std;

template<typename T>
class A 
{
public:
    void f() { cout << typeid(T).name() << endl; }
};

int main() 
{
	// 编译时模板类A会根据模版参数T的类型生成不同的类
    A<int> obj1;
    A<float> obj2;
    
    obj1.f(); // 输出i
    obj2.f(); // 输出f
    
    return 0;
}

函数重载：允许多个同名函数具有不同的参数列表，编译器在编译时根据函数调用的参数类型选择适当的函数。

void f(int i) { cout << "int" << endl; }

void f(char c) { cout << "char" << endl; }

int main() 
{
    f(1); // 输出 int
    f('c'); // 输出 char

    return 0;
}

3.1.2 动态多态

动态多态：在运行时决定函数调用的具体实现。
• 根据目标对象的动态类型和参数表中参数的静态类型确定目标代码体。
（虚函数和虚函数表）
• 根据目标对象的动态类型和参数表中参数的动态类型确定目标代码体。
（C++不支持）。

class B;

class A 
{
public:
    virtual ~A() {}

    virtual void f(A *) { cout << 1 << endl; }

    virtual void f(B *) { cout << 2 << endl; }
};

class B : public A 
{
public:
    virtual ~B() {}

    virtual void f(A *) { cout << 3 << endl; }

    virtual void f(B *) { cout << 4 << endl; }
};

int main() 
{
    B b;
    A* pa = &b;
    b.f(pa); // b的静态类型为B，参数pa静态类型为A*，B类中有f(A*)虚函数，采用动态编联，调用派生类的f(A *)函数，输出 3
    pa->f(pa); // pa的静态类型为A*，参数pa的静态类型为A*，A类中有f(A*)虚函数，采用动态编联，调用派生类的f(A *)函数，输出 3
    pa->f(&b); // pa的静态类型为A*，参数&b的静态类型为B*，A类中有f(B*)虚函数，采用动态编联，调用派生类的f(B *)函数，输出 4

    return 0;
}

3.2 虚拟的“拷贝构造函数”

在这里插入图片描述

class A {};

class B:public A{};

class C:public A{};

问题：如果有个位于A类继承树下的对象（可能为A/B/C…），现在希望提供一个统一接口，能拷贝出一个跟它一摸一样的对象。

因为需要根据对象类型拷贝出一个相同的对象，我们立马想到了拷贝构造函数，但是有两个问题，第一，拷贝构造函数不能为虚函数。第二，拷贝构造即便能为虚函数，各类中拷贝构造函数名也不一样，所以这个思路不行。我们想到可以在最顶层基类A中给一个函数，这个函数接受一个A*的参数，并根据实际指向类型调用对应类型拷贝构造函数，于是写出如下代码。

A* A::copy(const A &a) 
{
	if (typeid(A) == typeid(a)) {
	    return new A(a);
	} else if (typeid(B) == typeid(a)) {
	    return new B(static_cast<B &>(a));
	} else if (typeid(C) == typeid(a)) {
	    return new C(static_cast<C &>(a));
	}    
}

上面代码逻辑上没有问题，但难以适应变化，假设后续有派生类D、E…，需要不断在copy函数中增加新的类型判断。且对象具体类型识别需要RTTI，会有性能消耗。可以采用原型模式，在顶层基类A中提供一个名为clone虚函数，派生类中重写该虚函数解决前面的问题。

class A 
{
public:
    virtual A *clone() { return new A(*this); }

    A(const A &a); // 自定义实现
};

class B 
{
public:
    virtual B *clone() { return new B(*this); }

    B(const B &b); // 自定义实现
};

class C 
{
public:
    virtual C *clone() { return new C(*this); }

    C(const C &c); // 自定义实现
};

3.3 使用继承和虚函数的不足

只使用继承与虚函数，难以适应多个方向的变化。

class Parent
{
public:
    virtual ~Parent(){}

    virtual void F();

    virtual void G();

    virtual void H();
};

假设F()有两种不同的变化，G()有三种不同的变化，H()有四种不同的变化，那么需要2*3*4=24个派生类才能适应上面要求，如果后续某个函数有更多变化或新增虚函数，代码将难以维护。所以通常使用水平（关联、依赖）+ 继承。

class ImpF 
{
public:
    virtual ~ImpF() {}

    virtual void F();
};

class ImpG 
{
public:
    virtual ~ImpG() {}

    virtual void G();
};

class ImpH 
{
public:
    virtual ~ImpH() {}

    virtual void H();
};

class Parent 
{
public:
    Parent(ImpF *pf, ImpG *pg, ImpH *ph)
            : _pf(pf), _pg(pg), _ph(ph) {}

    virtual ~Parent() {}

    void F() { _pf->F(); };

    void G() { _pg->G(); };

    void H() { _ph->H(); };

private:
    ImpF *_pf;
    ImpG *_pg;
    ImpH *_ph;
};

我们定义ImpF、ImpG、ImpH三个基类，对于F()函数的两种变化只需要定义两个类继承ImpF类并重写F()函数即可，G()和H()依此类推，所以只需要定义2+3+4=9个派生类即可。Parent类中存放ImpF、ImpG、ImpH三个基类的指针。

四、扩展知识

4.1 具体类和抽象类

具体类：可以实例化对象的类
抽象类：为派生类提供更高层次的抽象，本身不能被实例化

抽象类说明：
• 含有一个或多个纯虚函数。
• 抽象类的派生类如果不重写纯虚函数,则还是抽象类
• 纯抽象类（接口类）：除静态、构造等函数均为纯虚函数，且没有任何非静态成员变量

纯虚函数：虚函数后面写上=0
语法：
virtual ReturnType Func（...）［const］ = 0；

纯虚函数说明：

必须为类的非静态成员函数。
纯虚函数通常是用来定义接口的，基类不会给出实现，而是要求派生类提供具体的实现。在提供一些默认行为或者进行一些公共操作时，纯虚函数是可以有定义的，但是必须在类外实现。

Shape.h文件

class Shape { //抽象类
public:
    virtual ~Shape() {}

    void Show() const { cout << "面积：" << Area() << endl; }

    virtual float area() const = 0;
};

class Rectangle : public Shape 
{
    virtual ~Rectangle() {}

    virtual float area() const { return w * h; }

private:
    int w;
    int h;
};

class Line : public Shape 
{
    virtual ~Line() {}

    //若Shape:area有纯虚定义，则下边可省略
    virtual float area() const { return 0; }
};

Shape.cpp文件

// 给出纯虚定义
float Shape::area() const { return 0; }

4.2 运行时类型识别(RTTI)

运行时类型识别 (Runtime Type Identification，RTTI)：是是C++中的一种机制，它允许在程序运行过程中确定对象的类型。

4.2.1 type_info

type_info类：一个与类型信息相关类，在标准头文件typeinfo定义，主要用于在运行时提供有关对象类型的信息。它通常与typeid运算符结合使用，typeid运算符结果是一个与之关联的 type_info 对象的引用，以便在程序运行时确定对象的类型。

不能直接实例化type_info 类的对象，因为该类只有一个private拷贝构造函数和一个protected构造函数，获取type_info 对象的唯一方式是使用 typeid 运算符。

type_info 类提供了一个查看类型名称的方法type_info::name()，以及与其他 type_info对象之间比较的函数（operator== 和 operator!=）。

说明：如果一个类有虚函数，则编译器在运行时会为这个类创建一个type_info对象，并将这个对象的地址存到该类虚表所在内存空间的前一个位置。

class Base 
{
public:
    virtual ~Base() {}

    void F() {}

    virtual void G() {}

protected:
    virtual void K() {}

    int _a;
};

class Derived: public Base
{
public:
    virtual ~Derived() {}

    void B() {}

    virtual void G() {}
    
    virtual void H() {}

    int _b;
};

在这里插入图片描述

4.2.2 typeid

用法：
typeid(type_name)
typeid(expr)

typeid 运算符允许在运行时确定对象的类，typeid 的结果是const type_info&。该值是对type_name或expr 的类型的 type_info 对象的引用。

说明：

type_name/expr是指针，则返回对应的静态类型
type_name/expr是对象或引用，且含有虚函数，则返回对应的动态类型

class Base 
{
public:
    virtual void f() {}
};

class Derived : public Base 
{
};

int main() {
    Base *p = new Derived;

    typeid(p) == typeid(Base *); // true
    typeid(p) == typeid(Derived *); // false
    typeid(*p) == typeid(Base); // false
    typeid(*p) == typeid(Derived); // true

    return 0;
}

4.2.3 dynamic_cast

dynamic_cast运算符一般用于包含继承关系且含有虚函数的向下类型转换。

转换过程（假设p为指向基类的指针）：

计算指针所指的对象的虚表地址，存放对象类型信息的type_info *指针在虚表前面, 然后解引用获取type_info信息，即 *(type_info*)p->vfptr[-1]
静态推导向下转型的目标类型的type_info信息，即获取类XX的type_info信息
比较两个type_info信息，若2）中的类型信息与1）中的类型信息相等或是其基类类型，则返回相应的对象或子对象的地址，否则返回nullptr

4.2.4 RTTI缺点

内存开销：RTTI 会为每个启用的类添加额外的元数据（如 type_info 对象），这会增加内存使用量。
运行时开销：使用 dynamic_cast 和 typeid 时，程序需要在运行时进行类型检查和比较，这会导致额外的运行时开销，特别是在类型层次复杂或转换频繁时，性能影响可能较大。
可移植性问题：尽管 RTTI 是 C++ 标准的一部分，但不同编译器对 RTTI 的实现可能有所不同。这意味着在跨平台开发时，可能会遇到与 RTTI 相关的可移植性问题。