C++ 自定义 `type_id` 机制：不依赖 RTTI 的类型识别

好的，各位观众，欢迎来到“不依赖 RTTI 的 C++ 类型识别奇妙之旅”！今天咱们要聊点硬核的，但保证用最接地气的方式，让大家听得懂，记得住，还能立马用得上。

开场白：RTTI，爱恨交织

首先，我们来聊聊 C++ 的 RTTI (Run-Time Type Information)。这玩意儿，用好了，是个类型识别的利器；用不好，就像个搅屎棍，让你的代码性能下降，编译时间变长。

RTTI 主要通过 typeid 运算符和 dynamic_cast 实现。typeid 返回一个 std::type_info 对象，告诉你一个表达式的类型；dynamic_cast 可以在运行时安全地进行向下转型。

但是！RTTI 有个大缺点：它会增加代码体积，并且运行时进行类型检查会带来性能开销。而且，有些嵌入式系统或者对性能要求极高的场景，会直接禁用 RTTI。

这时候，我们就需要另辟蹊径，寻找不依赖 RTTI 的类型识别方案。

方案一：手工打造类型 ID

最简单粗暴的方法，就是给每个类手动分配一个唯一的 ID。这就像给每个人发身份证号一样，简单直接。

#include <iostream>

// 定义一个枚举类型，用于表示不同的类型 ID
enum class TypeID {
    Base,
    DerivedA,
    DerivedB
};

class Base {
public:
    virtual ~Base() {} // 多态基类需要虚析构函数
    virtual TypeID GetTypeID() const { return TypeID::Base; }
};

class DerivedA : public Base {
public:
    TypeID GetTypeID() const override { return TypeID::DerivedA; }
};

class DerivedB : public Base {
public:
    TypeID GetTypeID() const override { return TypeID::DerivedB; }
};

int main() {
    Base* base1 = new Base();
    Base* derivedA = new DerivedA();
    Base* derivedB = new DerivedB();

    std::cout << "base1 type: " << static_cast<int>(base1->GetTypeID()) << std::endl;   // 输出 0
    std::cout << "derivedA type: " << static_cast<int>(derivedA->GetTypeID()) << std::endl; // 输出 1
    std::cout << "derivedB type: " << static_cast<int>(derivedB->GetTypeID()) << std::endl; // 输出 2

    delete base1;
    delete derivedA;
    delete derivedB;

    return 0;
}

优点：

简单易懂，实现起来非常方便。
性能高，类型识别只是一个枚举值的比较。
不依赖 RTTI，可以在禁用 RTTI 的环境下使用。

缺点：

需要手动维护类型 ID，容易出错。如果新增一个类，忘记分配 ID，或者分配了重复的 ID，就会导致程序出现 Bug。
可扩展性差，如果有很多类，手动维护 ID 会变得非常麻烦。
类型 ID 必须集中定义，如果类分散在不同的模块中，ID 的管理会更加困难。

方案二：静态多态 + std::is_same

如果你觉得手动维护类型 ID 太麻烦，可以考虑使用静态多态和 std::is_same。这种方法利用模板的特性，在编译时进行类型检查。

#include <iostream>
#include <type_traits>

template <typename T>
struct TypeIdentifier {
    using type = T;

    template <typename U>
    static constexpr bool is_type() {
        return std::is_same_v<T, U>;
    }
};

class Base {
public:
    virtual ~Base() {}
    virtual bool IsType(const TypeIdentifier<Base>& id) const {
        return id.is_type<Base>();
    }
};

class DerivedA : public Base {
public:
    bool IsType(const TypeIdentifier<DerivedA>& id) const override {
        return id.is_type<DerivedA>();
    }
};

class DerivedB : public Base {
public:
    bool IsType(const TypeIdentifier<DerivedB>& id) const override {
        return id.is_type<DerivedB>();
    }
};

int main() {
    Base* base1 = new Base();
    Base* derivedA = new DerivedA();
    Base* derivedB = new DerivedB();

    TypeIdentifier<Base> base_id;
    TypeIdentifier<DerivedA> derived_a_id;
    TypeIdentifier<DerivedB> derived_b_id;

    std::cout << "base1 is Base: " << base1->IsType(base_id) << std::endl;       // 输出 1
    std::cout << "base1 is DerivedA: " << base1->IsType(derived_a_id) << std::endl; // 输出 0
    std::cout << "derivedA is Base: " << derivedA->IsType(base_id) << std::endl;      // 输出 0 (因为调用的是Base的IsType)
    std::cout << "derivedA is DerivedA: " << derivedA->IsType(derived_a_id) << std::endl; // 输出 1
    std::cout << "derivedB is DerivedB: " << derivedB->IsType(derived_b_id) << std::endl; // 输出 1

    delete base1;
    delete derivedA;
    delete derivedB;

    return 0;
}

优点：

类型安全，在编译时进行类型检查，避免了运行时错误。
不需要手动维护类型 ID，减少了出错的可能性。
可扩展性较好，新增一个类只需要定义一个新的 TypeIdentifier 即可。

缺点：

代码稍微复杂一些，需要使用模板。
必须为每个需要识别的类型定义一个 TypeIdentifier，稍微有点冗余。
如果基类的 IsType 函数没有被子类重写，可能会导致类型识别错误 (如上面的例子所示)。

改进版本：CRTP + std::is_same

为了解决上面提到的基类 IsType 函数可能导致类型识别错误的问题，我们可以使用 CRTP (Curiously Recurring Template Pattern)，也叫奇异递归模板模式。

#include <iostream>
#include <type_traits>

template <typename Derived>
struct TypeIdentifier {
    using type = Derived;

    template <typename U>
    static constexpr bool is_type() {
        return std::is_same_v<Derived, U>;
    }

    bool IsType(const TypeIdentifier<Derived>& id) const {
        return id.is_type<Derived>();
    }
};

class Base : public TypeIdentifier<Base> {
public:
    virtual ~Base() {}
};

class DerivedA : public Base, public TypeIdentifier<DerivedA> {
public:
};

class DerivedB : public Base, public TypeIdentifier<DerivedB> {
public:
};

int main() {
    Base* base1 = new Base();
    Base* derivedA = new DerivedA();
    Base* derivedB = new DerivedB();

    TypeIdentifier<Base> base_id;
    TypeIdentifier<DerivedA> derived_a_id;
    TypeIdentifier<DerivedB> derived_b_id;

    std::cout << "base1 is Base: " << static_cast<Base*>(base1)->IsType(base_id) << std::endl;       // 输出 1
    std::cout << "base1 is DerivedA: " << static_cast<Base*>(base1)->IsType(derived_a_id) << std::endl; // 输出 0
    std::cout << "derivedA is Base: " << static_cast<Base*>(derivedA)->IsType(base_id) << std::endl;      // 输出 0
    std::cout << "derivedA is DerivedA: " << static_cast<Base*>(derivedA)->IsType(derived_a_id) << std::endl; // 输出 1
    std::cout << "derivedB is DerivedB: " << static_cast<Base*>(derivedB)->IsType(derived_b_id) << std::endl; // 输出 1

    delete base1;
    delete derivedA;
    delete derivedB;

    return 0;
}

优点：

避免了虚函数调用，性能更高。
类型安全，在编译时进行类型检查。
不需要手动维护类型 ID。

缺点：

代码更加复杂，需要理解 CRTP 的原理。
继承结构更加复杂，每个需要识别的类都需要继承 TypeIdentifier。

方案三：利用虚函数表指针的唯一性

每个类都有一个虚函数表，虚函数表指针 (vptr) 指向该类的虚函数表。如果两个对象的类型相同，它们的 vptr 指向的地址也相同。我们可以利用这个特性来进行类型识别。

注意： 这种方法依赖于编译器的实现细节，不同的编译器可能对虚函数表的布局有所不同，因此这种方法的移植性较差。强烈不推荐在生产环境中使用！ 这里只是为了展示一种可能的思路。

#include <iostream>

class Base {
public:
    virtual ~Base() {}
    virtual void SomeVirtualFunction() {}
};

class DerivedA : public Base {
public:
    void SomeVirtualFunction() override {}
};

class DerivedB : public Base {
public:
    void SomeVirtualFunction() override {}
};

// 获取对象的虚函数表指针
template <typename T>
uintptr_t GetVTable(T* obj) {
    return *reinterpret_cast<uintptr_t*>(obj);
}

int main() {
    Base* base1 = new Base();
    Base* derivedA = new DerivedA();
    Base* derivedB = new DerivedB();

    uintptr_t base_vtable = GetVTable(base1);
    uintptr_t derived_a_vtable = GetVTable(derivedA);
    uintptr_t derived_b_vtable = GetVTable(derivedB);

    std::cout << "base1 vtable: " << base_vtable << std::endl;
    std::cout << "derivedA vtable: " << derived_a_vtable << std::endl;
    std::cout << "derivedB vtable: " << derived_b_vtable << std::endl;

    // 类型识别 (非常不建议！)
    if (GetVTable(base1) == base_vtable) {
        std::cout << "base1 is Base" << std::endl;
    }
    if (GetVTable(derivedA) == derived_a_vtable) {
        std::cout << "derivedA is DerivedA" << std::endl;
    }
    if (GetVTable(derivedB) == derived_b_vtable) {
        std::cout << "derivedB is DerivedB" << std::endl;
    }

    delete base1;
    delete derivedA;
    delete derivedB;

    return 0;
}

优点：

理论上性能最高，只需要比较指针。

缺点：

极度不安全！ 依赖于编译器实现细节，移植性极差。
如果编译器对虚函数表进行优化，可能会导致类型识别错误。
代码可读性差，难以维护。

方案四：std::variant + Visitor 模式

如果你的类型是有限的，并且在编译时已知，可以考虑使用 std::variant 和 Visitor 模式。 std::variant 可以存储多个不同类型的值，而 Visitor 模式可以对 std::variant 中存储的值进行操作。

#include <iostream>
#include <variant>

class Base {
public:
    virtual ~Base() {}
    virtual void Accept(class Visitor& visitor) = 0;
};

class DerivedA : public Base {
public:
    void Accept(class Visitor& visitor) override;
};

class DerivedB : public Base {
public:
    void Accept(class Visitor& visitor) override;
};

class Visitor {
public:
    virtual void Visit(Base& base) { std::cout << "Visiting Base" << std::endl; }
    virtual void Visit(DerivedA& a) { std::cout << "Visiting DerivedA" << std::endl; }
    virtual void Visit(DerivedB& b) { std::cout << "Visiting DerivedB" << std::endl; }
};

void DerivedA::Accept(Visitor& visitor) { visitor.Visit(*this); }
void DerivedB::Accept(Visitor& visitor) { visitor.Visit(*this); }

int main() {
    std::variant<Base*, DerivedA*, DerivedB*> myVariant;

    DerivedA* a = new DerivedA();
    DerivedB* b = new DerivedB();

    myVariant = a;
    Visitor visitor;

    if (std::holds_alternative<DerivedA*>(myVariant)) {
        DerivedA* ptr = std::get<DerivedA*>(myVariant);
        ptr->Accept(visitor); // 输出 Visiting DerivedA
    }

    myVariant = b;
    if (std::holds_alternative<DerivedB*>(myVariant)) {
        DerivedB* ptr = std::get<DerivedB*>(myVariant);
        ptr->Accept(visitor); // 输出 Visiting DerivedB
    }

    delete a;
    delete b;

    return 0;
}

优点：

类型安全，在编译时进行类型检查。
可以处理多个不同类型的值。
Visitor 模式可以方便地对 std::variant 中存储的值进行操作。

缺点：

需要定义 Visitor 类和 Accept 函数，代码稍微复杂。
只适用于类型有限且在编译时已知的情况。
运行时需要检查 std::variant 中存储的类型。

总结：选择适合你的方案

方案	优点	缺点	适用场景
手工打造类型 ID	简单易懂，性能高，不依赖 RTTI	需要手动维护类型 ID，容易出错，可扩展性差	简单场景，类型数量较少，对性能要求较高
静态多态 + `std::is_same`	类型安全，不需要手动维护类型 ID，可扩展性较好	代码稍微复杂，需要为每个类型定义 `TypeIdentifier`，基类 `IsType` 函数可能导致类型识别错误	类型数量适中，对类型安全有一定要求
CRTP + `std::is_same`	避免了虚函数调用，性能更高，类型安全，不需要手动维护类型 ID	代码更加复杂，继承结构更加复杂	对性能要求较高，类型数量适中
利用虚函数表指针	理论上性能最高	极度不安全！依赖于编译器实现细节，移植性极差，如果编译器对虚函数表进行优化，可能会导致类型识别错误，代码可读性差，难以维护。强烈不建议在生产环境中使用！	绝对不要用！除非你非常清楚你在做什么，并且愿意承担一切风险
`std::variant` + Visitor	类型安全，可以处理多个不同类型的值，Visitor 模式可以方便地对 `std::variant` 中存储的值进行操作	需要定义 Visitor 类和 `Accept` 函数，代码稍微复杂，只适用于类型有限且在编译时已知的情况，运行时需要检查 `std::variant` 中存储的类型	类型有限且在编译时已知，需要处理多个不同类型的值

选择哪种方案，取决于你的具体需求和场景。没有银弹，只有最合适的方案。

最后的忠告：

在选择类型识别方案时，一定要权衡性能、安全性、可维护性和可扩展性。
尽量避免使用依赖于编译器实现细节的方案。
如果可以，尽量使用 C++ 标准库提供的工具。
代码写完之后，一定要进行充分的测试。

好了，今天的分享就到这里。希望大家有所收获，能够在自己的项目中选择合适的类型识别方案。谢谢大家！

发表回复 取消回复

发表回复取消回复