类型身份证 · RTTI

在 C++ 的世界里，每个类型都有自己的"身份证"。当你拿到一个基类指针时，如何知道它实际指向的是什么类型的对象？这就是 RTTI（Run-Time Type Information，运行时类型信息）的用武之地。

---

typeid 运算符

typeid 是查询类型信息的基本工具：

#include <iostream>
#include <typeinfo>

class Animal
{
public:
    virtual ~Animal() = default;
    virtual void speak() = 0;
};

class Dog : public Animal
{
public:
    void speak() override { std::cout << "Woof!" << std::endl; }
};

class Cat : public Animal
{
public:
    void speak() override { std::cout << "Meow!" << std::endl; }
};

int main()
{
    // 基本类型
    int x = 42;
    std::cout << "Type of x: " << typeid(x).name() << std::endl;
    std::cout << "Type of 3.14: " << typeid(3.14).name() << std::endl;
    
    // 类类型
    Dog dog;
    Cat cat;
    std::cout << "Type of dog: " << typeid(dog).name() << std::endl;
    std::cout << "Type of cat: " << typeid(cat).name() << std::endl;
    
    // 多态类型（通过基类指针）
    Animal* animal = &dog;
    std::cout << "Type of *animal: " << typeid(*animal).name() << std::endl;
    
    animal = &cat;
    std::cout << "Type of *animal: " << typeid(*animal).name() << std::endl;
    
    return 0;
}

注意：typeid().name() 的输出是编译器相关的，可能是修饰过的名称。

---

type_info 类

typeid 返回 std::type_info 对象的引用：

#include <iostream>
#include <typeinfo>

class Base { public: virtual ~Base() = default; };
class Derived : public Base {};

int main()
{
    Derived d;
    Base& b = d;
    
    const std::type_info& ti1 = typeid(d);
    const std::type_info& ti2 = typeid(b);
    
    std::cout << "ti1.name(): " << ti1.name() << std::endl;
    std::cout << "ti2.name(): " << ti2.name() << std::endl;
    
    // 比较类型
    std::cout << "Same type: " << (ti1 == ti2) << std::endl;  // 1
    std::cout << "Before: " << ti1.before(typeid(int)) << std::endl;
    
    // 获取 hash
    std::cout << "Hash of ti1: " << ti1.hash_code() << std::endl;
    std::cout << "Hash of ti2: " << ti2.hash_code() << std::endl;
    
    return 0;
}

---

dynamic_cast：安全的向下转型

dynamic_cast 用于在继承层次中安全地转换指针或引用：

#include <iostream>

class Animal
{
public:
    virtual ~Animal() = default;
    virtual void speak() const = 0;
};

class Dog : public Animal
{
public:
    void speak() const override { std::cout << "Woof!" << std::endl; }
    void fetch() const { std::cout << "Fetching..." << std::endl; }
};

class Cat : public Animal
{
public:
    void speak() const override { std::cout << "Meow!" << std::endl; }
    void purr() const { std::cout << "Purring..." << std::endl; }
};

void interact(Animal* animal)
{
    animal->speak();
    
    // 尝试转换为 Dog
    if (Dog* dog = dynamic_cast<Dog*>(animal))
    {
        dog->fetch();  // Dog 特有的方法
    }
    // 尝试转换为 Cat
    else if (Cat* cat = dynamic_cast<Cat*>(animal))
    {
        cat->purr();   // Cat 特有的方法
    }
}

int main()
{
    Dog dog;
    Cat cat;
    
    std::cout << "=== Dog ===" << std::endl;
    interact(&dog);
    
    std::cout << "\n=== Cat ===" << std::endl;
    interact(&cat);
    
    return 0;
}

引用的 dynamic_cast

对引用使用 dynamic_cast 时，失败会抛出异常：

#include <iostream>
#include <typeinfo>

class Base { public: virtual ~Base() = default; };
class Derived : public Base {};
class Other : public Base {};

void convert(Base& b)
{
    try
    {
        Derived& d = dynamic_cast<Derived&>(b);
        std::cout << "Successfully cast to Derived" << std::endl;
    }
    catch (const std::bad_cast& e)
    {
        std::cout << "Cast failed: " << e.what() << std::endl;
    }
}

int main()
{
    Derived d;
    Other o;
    
    convert(d);  // 成功
    convert(o);  // 抛出 std::bad_cast
    
    return 0;
}

---

RTTI 的性能考量

RTTI 有一定的运行时开销。在性能敏感的代码中，有几种替代方案：

1. 虚函数代替 dynamic_cast

class Animal
{
public:
    virtual ~Animal() = default;
    virtual void speak() const = 0;
    
    // 添加类型查询方法
    virtual bool isDog() const { return false; }
    virtual bool isCat() const { return false; }
    
    // 或者：访问者模式
    virtual void accept(class Visitor& v) = 0;
};

class Dog : public Animal
{
public:
    void speak() const override { std::cout << "Woof!" << std::endl; }
    bool isDog() const override { return true; }
    void fetch() const { std::cout << "Fetching..." << std::endl; }
    void accept(Visitor& v) override;
};

2. 枚举类型标记

#include <iostream>

class GameObject
{
public:
    enum class Type { Player, Enemy, Item, Projectile };
    
    virtual ~GameObject() = default;
    virtual Type getType() const = 0;
};

class Player : public GameObject
{
public:
    Type getType() const override { return Type::Player; }
    void jump() { std::cout << "Jumping!" << std::endl; }
};

class Enemy : public GameObject
{
public:
    Type getType() const override { return Type::Enemy; }
    void attack() { std::cout << "Attacking!" << std::endl; }
};

void handleObject(GameObject* obj)
{
    switch (obj->getType())
    {
        case GameObject::Type::Player:
            static_cast<Player*>(obj)->jump();
            break;
        case GameObject::Type::Enemy:
            static_cast<Enemy*>(obj)->attack();
            break;
        default:
            break;
    }
}

---

访问者模式：类型安全的替代方案

#include <iostream>
#include <vector>
#include <memory>

// 前向声明
class Circle;
class Rectangle;
class Triangle;

// 访问者接口
class ShapeVisitor
{
public:
    virtual ~ShapeVisitor() = default;
    virtual void visit(Circle& c) = 0;
    virtual void visit(Rectangle& r) = 0;
    virtual void visit(Triangle& t) = 0;
};

// 形状基类
class Shape
{
public:
    virtual ~Shape() = default;
    virtual void accept(ShapeVisitor& v) = 0;
};

// 具体形状
class Circle : public Shape
{
public:
    double radius = 5.0;
    void accept(ShapeVisitor& v) override { v.visit(*this); }
};

class Rectangle : public Shape
{
public:
    double width = 4.0, height = 3.0;
    void accept(ShapeVisitor& v) override { v.visit(*this); }
};

class Triangle : public Shape
{
public:
    double base = 3.0, height = 4.0;
    void accept(ShapeVisitor& v) override { v.visit(*this); }
};

// 具体访问者：计算面积
class AreaCalculator : public ShapeVisitor
{
public:
    double totalArea = 0.0;
    
    void visit(Circle& c) override
    {
        totalArea += 3.14159 * c.radius * c.radius;
    }
    
    void visit(Rectangle& r) override
    {
        totalArea += r.width * r.height;
    }
    
    void visit(Triangle& t) override
    {
        totalArea += 0.5 * t.base * t.height;
    }
};

// 具体访问者：绘制形状
class Renderer : public ShapeVisitor
{
public:
    void visit(Circle& c) override
    {
        std::cout << "Drawing circle with radius " << c.radius << std::endl;
    }
    
    void visit(Rectangle& r) override
    {
        std::cout << "Drawing rectangle " << r.width << "x" << r.height << std::endl;
    }
    
    void visit(Triangle& t) override
    {
        std::cout << "Drawing triangle with base " << t.base << std::endl;
    }
};

int main()
{
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>());
    shapes.push_back(std::make_unique<Rectangle>());
    shapes.push_back(std::make_unique<Triangle>());
    
    AreaCalculator calc;
    Renderer renderer;
    
    for (auto& shape : shapes)
    {
        shape->accept(calc);
        shape->accept(renderer);
    }
    
    std::cout << "\nTotal area: " << calc.totalArea << std::endl;
    
    return 0;
}

---

std::any 与 std::variant（C++17）

现代 C++ 提供了类型安全的动态类型容器：

#include <iostream>
#include <any>
#include <variant>
#include <string>

void anyExample()
{
    std::cout << "=== std::any ===" << std::endl;
    
    std::any value = 42;
    std::cout << "Type: " << value.type().name() << std::endl;
    std::cout << "Value: " << std::any_cast<int>(value) << std::endl;
    
    value = std::string("Hello");
    std::cout << "Type: " << value.type().name() << std::endl;
    std::cout << "Value: " << std::any_cast<std::string>(value) << std::endl;
    
    // 类型检查
    if (value.type() == typeid(std::string))
    {
        std::cout << "It's a string!" << std::endl;
    }
    
    // 安全获取（失败返回 nullptr）
    if (auto* ptr = std::any_cast<int>(&value))
    {
        std::cout << "Int value: " << *ptr << std::endl;
    }
    else
    {
        std::cout << "Not an int!" << std::endl;
    }
}

void variantExample()
{
    std::cout << "\n=== std::variant ===" << std::endl;
    
    std::variant<int, double, std::string> value = 42;
    
    // 获取当前类型索引
    std::cout << "Index: " << value.index() << std::endl;
    
    // 使用 std::get
    std::cout << "Value: " << std::get<int>(value) << std::endl;
    
    // 使用 std::get_if（安全版本）
    if (auto* ptr = std::get_if<int>(&value))
    {
        std::cout << "Int value: " << *ptr << std::endl;
    }
    
    // 使用 std::visit
    value = std::string("Hello");
    
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, int>)
            std::cout << "int: " << arg << std::endl;
        else if constexpr (std::is_same_v<T, double>)
            std::cout << "double: " << arg << std::endl;
        else if constexpr (std::is_same_v<T, std::string>)
            std::cout << "string: " << arg << std::endl;
    }, value);
    
    // 使用 std::holds_alternative
    if (std::holds_alternative<std::string>(value))
    {
        std::cout << "It's a string!" << std::endl;
    }
}

int main()
{
    anyExample();
    variantExample();
    return 0;
}

---

实现简单的反射系统

#include <iostream>
#include <map>
#include <string>
#include <functional>
#include <memory>

// 类型注册系统
class TypeRegistry
{
public:
    using Creator = std::function<void*()>;
    
    static TypeRegistry& instance()
    {
        static TypeRegistry registry;
        return registry;
    }
    
    void registerType(const std::string& name, Creator creator)
    {
        creators[name] = creator;
    }
    
    void* create(const std::string& name) const
    {
        auto it = creators.find(name);
        return (it != creators.end()) ? it->second() : nullptr;
    }
    
private:
    std::map<std::string, Creator> creators;
};

// 自动注册宏
#define REGISTER_TYPE(Type) \
    static bool Type##_registered = []() { \
        TypeRegistry::instance().registerType(#Type, []() -> void* { \
            return new Type(); \
        }); \
        return true; \
    }();

// 示例类
class Animal
{
public:
    virtual ~Animal() = default;
    virtual void speak() const = 0;
};

class Dog : public Animal
{
public:
    void speak() const override { std::cout << "Woof!" << std::endl; }
};
REGISTER_TYPE(Dog)

class Cat : public Animal
{
public:
    void speak() const override { std::cout << "Meow!" << std::endl; }
};
REGISTER_TYPE(Cat)

class Bird : public Animal
{
public:
    void speak() const override { std::cout << "Tweet!" << std::endl; }
};
REGISTER_TYPE(Bird)

int main()
{
    // 通过字符串名称创建对象
    std::vector<std::string> animalTypes = {"Dog", "Cat", "Bird", "Dog"};
    
    std::vector<std::unique_ptr<Animal>> animals;
    
    for (const auto& type : animalTypes)
    {
        Animal* animal = static_cast<Animal*>(
            TypeRegistry::instance().create(type)
        );
        if (animal)
        {
            animals.emplace_back(animal);
        }
    }
    
    for (const auto& animal : animals)
    {
        animal->speak();
    }
    
    return 0;
}

---

禁用 RTTI

在某些嵌入式系统或对代码大小敏感的环境中，可以禁用 RTTI：

// 编译选项:
// GCC/Clang: -fno-rtti
// MSVC: /GR-

// 禁用后，以下代码将无法使用：
// - typeid
// - dynamic_cast

// 替代方案：手动实现类型识别
class MyBase
{
public:
    virtual ~MyBase() = default;
    
    // 手动类型 ID
    enum class TypeId { Base, Derived1, Derived2 };
    virtual TypeId getTypeId() const { return TypeId::Base; }
    
    template<typename T>
    T* as()
    {
        if (getTypeId() == T::staticTypeId())
            return static_cast<T*>(this);
        return nullptr;
    }
};

class Derived1 : public MyBase
{
public:
    static TypeId staticTypeId() { return TypeId::Derived1; }
    TypeId getTypeId() const override { return TypeId::Derived1; }
};

---

总结

特性	用途	性能
typeid	获取类型信息	中等
dynamic_cast	安全向下转型	较慢
虚函数	多态行为	快
枚举标记	类型识别	最快
访问者模式	类型安全的双分派	快
std::any	类型擦除容器	中等
std::variant	类型安全的联合	快

RTTI 是 C++ 的强大特性，但要明智地使用。在性能关键的代码中，考虑使用虚函数或其他替代方案。记住：每个类型都有自己的"身份证"，但查验身份证是要付出代价的！