15. 智能指针与动态类型：typeid与dynamic_cast的正确使用

说实话，动态类型识别这个话题，在C++里一直有点「玄学」的味道。很多初学者觉得它没用，老手又容易用出问题。我最早接触智能指针和动态类型混用的时候，就踩过一个大坑——当时用shared_ptr管理一组派生类对象，想通过dynamic_cast做类型转换，结果编译过了，运行却崩了。后来才发现，问题出在typeid的行为上。

今天我们就来聊聊，在智能指针的语境下，typeid和dynamic_cast到底该怎么用。说白了，就是让你知道什么时候该用、怎么用、以及千万别怎么用。

15.1 typeid 与智能指针：小心「裸指针陷阱」

typeid这个运算符，用来获取对象的类型信息。它返回一个std::type_info对象，可以比较类型是否相等。但有个细节很多人不知道——typeid作用于指针和作用于对象，结果完全不同。

看个例子：

#include <iostream>
#include <memory>
#include <typeinfo>

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

int main() {
    std::shared_ptr<Base> sp = std::make_shared<Derived>();

    // 错误用法：对智能指针本身取 typeid
    std::cout << typeid(sp).name() << std::endl;  // 输出 shared_ptr<Base>

    // 正确用法：对解引用后的对象取 typeid
    std::cout << typeid(*sp).name() << std::endl; // 输出 Derived

    return 0;
}

看到了吗？typeid(sp)返回的是智能指针本身的类型，而不是它指向的对象类型。我见过不少同事在调试时用typeid(sp).name()来确认对象类型，结果被误导了半天。

15.2 dynamic_cast 与智能指针：别直接转智能指针

dynamic_cast用于安全地将基类指针或引用转换为派生类指针或引用。但智能指针本身不是指针，你不能直接写dynamic_cast<std::shared_ptr<Derived>>(sp)——编译器会直接报错。

正确的做法是：先对智能指针解引用，用dynamic_cast转换裸指针，再重新包装成智能指针。但这里有个坑：如果你直接构造一个新的shared_ptr，会导致两个智能指针管理同一块内存，引用计数却各自独立，最终造成double free。

我给大家推荐两种安全的方式：

方式一：使用 std::dynamic_pointer_cast

C++11 提供了std::dynamic_pointer_cast，专门用来在智能指针之间做动态类型转换。它会自动处理引用计数，保证内存安全。

#include <iostream>
#include <memory>

class Base { virtual void f() {} };
class Derived : public Base {
public:
    void specific() { std::cout << "Derived::specific()\n"; }
};

int main() {
    std::shared_ptr<Base> sp = std::make_shared<Derived>();

    // 安全转换
    std::shared_ptr<Derived> dp = std::dynamic_pointer_cast<Derived>(sp);
    if (dp) {
        dp->specific();
    }

    return 0;
}

我个人习惯，只要涉及智能指针的动态类型转换，一律用std::dynamic_pointer_cast。它内部实现就是先对裸指针做dynamic_cast，如果成功，再构造一个新的shared_ptr并共享控制块。这样既安全又简洁。

方式二：手动转换 + 自定义删除器（不推荐）

如果你非要用裸指针那一套，也可以：

Derived* raw_dp = dynamic_cast<Derived*>(sp.get());
if (raw_dp) {
    // 注意：这里不能直接构造 shared_ptr，会破坏所有权
    // 只能作为观察者使用，不能延长生命周期
}

嗯，这种方式我强烈不推荐。你想想看，sp.get()返回的裸指针，如果被外部构造了另一个shared_ptr，那原始shared_ptr释放时，第二个shared_ptr就成了悬空指针。我曾经在一个遗留项目里见过这种写法，排查了整整两天才找到bug根源。

15.3 typeid 与 dynamic_cast 的协作场景

在实际项目中，我经常把typeid和dynamic_cast搭配使用。比如在工厂模式或消息分发系统中，先通过typeid快速判断类型，再决定是否做dynamic_cast。

#include <iostream>
#include <memory>
#include <typeinfo>
#include <unordered_map>
#include <functional>

class Message {
public:
    virtual ~Message() = default;
    virtual int type() const = 0;
};

class TextMessage : public Message {
public:
    int type() const override { return 1; }
    std::string text;
};

class ImageMessage : public Message {
public:
    int type() const override { return 2; }
    std::vector<uint8_t> data;
};

// 消息分发器
class Dispatcher {
public:
    using Handler = std::function<void(std::shared_ptr<Message>)>;

    template<typename T>
    void registerHandler(Handler handler) {
        handlers_[typeid(T).hash_code()] = handler;
    }

    void dispatch(std::shared_ptr<Message> msg) {
        auto it = handlers_.find(typeid(*msg).hash_code());
        if (it != handlers_.end()) {
            it->second(msg);
        }
    }
};

int main() {
    Dispatcher disp;

    // 注册文本消息处理器
    disp.registerHandler<TextMessage>([](std::shared_ptr<Message> msg) {
        auto textMsg = std::dynamic_pointer_cast<TextMessage>(msg);
        if (textMsg) {
            std::cout << "处理文本: " << textMsg->text << std::endl;
        }
    });

    // 发送消息
    auto msg = std::make_shared<TextMessage>();
    msg->text = "Hello, world!";
    disp.dispatch(msg);

    return 0;
}

这个模式的好处是：typeid做快速路由，dynamic_pointer_cast做安全转换。两者配合，既高效又安全。

15.4 性能与注意事项

说到性能，typeid和dynamic_cast都不是免费的午餐。它们依赖RTTI（运行时类型信息），而RTTI的实现通常涉及虚函数表的查找。我做过一些性能测试，大致数据如下：

操作	相对耗时（1x为普通虚函数调用）	说明
普通虚函数调用	1x	通过vtable直接跳转
typeid(*sp)	2-3x	读取vtable中的类型信息指针
dynamic_cast（成功）	5-10x	遍历继承链，比较类型信息
dynamic_cast（失败）	10-20x	需要遍历完整继承链确认失败

所以，如果你在性能敏感的循环里频繁做动态类型转换，建议重新设计架构。比如用虚函数替代，或者用std::variant + std::visit。

15.5 知识体系总览

下面这张图，帮你理清智能指针与动态类型的关系：

15.6 避坑指南

最后，我把自己这些年踩过的坑总结一下，希望能帮你少走弯路：

• 坑1：在模板函数里用typeid(T)判断类型。模板实例化后，typeid(T)是编译期确定的，不是动态类型。要用typeid(*ptr)才行。
• 坑2：对unique_ptr做动态类型转换。unique_ptr不支持dynamic_pointer_cast，因为所有权不能共享。你需要先move出来，转换后再重新包装。
• 坑3：在析构函数里调用dynamic_cast。对象正在析构时，动态类型已经退化为基类，dynamic_cast会失败。

我曾经在一个网络库的析构函数里用了dynamic_cast，结果每次程序退出时都崩溃。查了三天才发现，是析构顺序导致对象类型已经变了。从那以后，我给自己定了个规矩：析构函数里绝对不用任何RTTI操作。

好了，关于智能指针与动态类型，核心就是这些。记住三个关键词：typeid(*sp)、std::dynamic_pointer_cast、以及「永远不要从get()构造新shared_ptr」。做到这三点，你就能在智能指针的世界里安全地玩转动态类型了。