dynamic_cast的理解

news2025/3/30 7:20:13

dynamic_cast：（具体使用就不详细说明了）

C++ 中用于安全的类层次结构转换的类型转换运算符，主要用于多态类型（即包含虚函数的类）的指针或引用之间的转换

前提条件：

必须要有虚函数才能使用 dynamic_cast。即使存在单纯的继承关系，如果基类没有虚函数，dynamic_cast 无法使用

原因：

1. 为什么必须要有虚函数？

dynamic_cast 依赖 运行时类型信息（RTTI），而 RTTI 是通过虚函数表（vtable）实现的。

虚函数表（vtable）：当一个类包含虚函数时，编译器会为该类生成虚函数表，并在对象中插入指向该表的指针（vptr）。
RTTI 的存储：虚函数表中会保存类的类型信息（如类型名称、继承关系等），供 dynamic_cast 在运行时查询。
没有虚函数 → 没有虚函数表 → 没有 RTTI → dynamic_cast 无法工作。

2. 示例验证

代码示例（基类无虚函数）

#include <iostream>

class Base {};  // 基类没有虚函数
class Derived : public Base {};

int main() {
    Base* base = new Derived();
    
    // 尝试使用 dynamic_cast（编译错误！）
    Derived* derived = dynamic_cast<Derived*>(base);  
    
    delete base;
    return 0;
}

编译错误信息

error: 'Base' is not polymorphic
     Derived* derived = dynamic_cast<Derived*>(base);
                                     ^

3. 单纯继承无法使用 `dynamic_cast`

即使存在继承关系，只要基类没有虚函数：

dynamic_cast 无法编译通过，因为基类不是多态类型。
无法进行安全的运行时类型检查。

工作原理：

首先，dynamic_cast的核心在于运行时类型检查。这通常通过对象的虚函数表（vtable）中的RTTI指针来实现。每个多态类（即有虚函数的类）的虚函数表都包含一个指向type_info的指针，该指针提供了类的类型信息。当进行dynamic_cast时，编译器生成的代码会遍历继承树，检查目标类型是否是当前类型或其派生类(个人觉得是比较 hash_code（），而不是name())

class type_info
{
public:

    type_info(const type_info&) = delete;
    type_info& operator=(const type_info&) = delete;

    size_t hash_code() const noexcept
    {
        return __std_type_info_hash(&_Data);
    }

    bool operator==(const type_info& _Other) const noexcept
    {
        return __std_type_info_compare(&_Data, &_Other._Data) == 0;
    }

#if !_HAS_CXX20
    bool operator!=(const type_info& _Other) const noexcept
    {
        return __std_type_info_compare(&_Data, &_Other._Data) != 0;
    }
#endif // !_HAS_CXX20

    bool before(const type_info& _Other) const noexcept
    {
        return __std_type_info_compare(&_Data, &_Other._Data) < 0;
    }

    const char* name() const noexcept
    {
        #ifdef _M_CEE_PURE
        return __std_type_info_name(&_Data, static_cast<__type_info_node*>(__type_info_root_node.ToPointer()));
        #else
        return __std_type_info_name(&_Data, &__type_info_root_node);
        #endif
    }

    const char* raw_name() const noexcept
    {
        return _Data._DecoratedName;
    }

    virtual ~type_info() noexcept;

private:

    mutable __std_type_info_data _Data;
};

性能开销来源:

虚表访问: 需通过虚表获取 type_info，可能引发缓存未命中。

// 伪代码：获取动态类型
const __class_type_info* __get_dynamic_type(const void* obj) {
    // 获取虚表指针（通常位于对象起始位置）
    const void** vtable = *reinterpret_cast<const void***>(obj);
    // 虚表中存储了 type_info 指针（通常位于固定位置，如 -1 偏移）
    const __class_type_info* type_info = vtable[-1];
    return type_info;
}

继承链遍历： 递归检查继承关系的复杂度为 O(继承深度)。

// 伪代码：检查继承关系
bool __do_find(const __class_type_info* target) const {
    if (this == target) {
        return true;  // 当前类型就是目标类型
    }

    // 遍历基类列表
    if (is_single_inheritance()) {
        return __base_type->__do_find(target);  // 单继承递归
    } else {
        for (each base in __base_info) {         // 多继承递归
            if (base.__base_type->__do_find(target)) {
                return true;
            }
        }
    }
    return false;
}

指针调整计算： 多重继承中可能需要复杂偏移计算。(在多重继承中，不同基类的子对象可能有不同的偏移量，需调整指针：)

// 伪代码：调整指针偏移
void* adjust_pointer(const void* src, const __class_type_info* src_type, const __class_type_info* target_type) {
    // 计算从源类型到目标类型的偏移量
    ptrdiff_t offset = calculate_offset(src_type, target_type);
    return reinterpret_cast<char*>(src) + offset;
}

判断两个类是否有继承关系：

方法	检查时机	适用范围	优点	缺点
`std::is_base_of`	编译时	任意类之间的继承关系	简单、标准	不能检查多态对象的具体类型
`typeid` 和 `dynamic_cast`	运行时	多态类型的具体对象	可以检查实际对象类型	依赖 RTTI，性能开销