C++：模拟 RTTI

Question

我有一个这样的类层次结构：

class A        { }                            //
class AA  : A  { }                            //          A
class AAA : AA { }                            //        /   \
class AAB : AA { }                            //      AA     AB
class AB  : A  { }                            //     / \     / \
class ABA : AB { }                            //   AAA AAB ABA ABB
class ABB : AB { }                            //

我想为这个层次结构模拟 RTTI（当然不使用它），在某种程度上，给定一个指向 A 的指针/引用，我可以找出它的实际类型（类似于 typeid 的作用），作为标识类的整数。

此外，我希望标识我的类型的整数集是连续的，并且从 0 到 N-1（在我的示例中从 0 到 6）：（

class A        { virtual int t(){return 0;} } //
class AA  : A  { virtual int t(){return 1;} } //            A(0)
class AAA : AA { virtual int t(){return 2;} } //          /      \
class AAB : AA { virtual int t(){return 3;} } //      AA(1)       AB(4)
class AB  : A  { virtual int t(){return 4;} } //     /   \        /    \
class ABA : AB { virtual int t(){return 5;} } // AAA(2) AAB(3) ABA(5) ABB(6)
class ABB : AB { virtual int t(){return 6;} } //

顺序并不重要：A::t<例如， /code> 可以返回 3 和 AAB::t 0 ，

---

是否可以让编译器将索引分配给我的类

？ .wikipedia.org/wiki/Curiously_recurring_template_pattern" rel="noreferrer">CRTP 可以帮助我；类似：

class X : A, AssignFirstAvailableIndex< X > { }

但我对模板不够擅长。我如何实现 AssignFirstAvailableIndex模板类？

（当然编译器可以在编译时看到所有的类）

Answer 1

有一个标准方法可以实现您的需要。标准区域设置方面使用它来标识自己。考虑检查标准标头“区域设置”。

class Base {
  public:
  // Being constructed contains a new unique identifier
  class Id {
    // An id factory returns a sequence of nonnegative ints
    static int allocate() {
      static int total = 0;
      return total++;
    }
    int _local;
    public:
    Id(): _local(allocate()) {}
    int get() const {return _local;}
  };
  //Child classes should make this function return an id generated by Base::Id constructed as static member.
  virtual int id() const = 0;
};

class Child1{
  public:
  static const Base::Id _id; 
  virtual int id() { return _id.get(); }
};

class Child2 {
  public:
  static const Base::Id _id; 
  virtual int id() { return _id.get(); }
};

class Child3 {
  public:
  static const Base::Id _id; 
  virtual int id() { return _id.get(); }
};

静态成员可以在实现文件中初始化，或者被模板化以允许直接从标头实例化，或者被重构以进行延迟初始化。

Answer 2

也许是这样的？ （语法可能到处都是错误的，但你明白了）

class A {
  virtual int t() { return 0; }
}

template <bool AB>
class AX<AB>: A {
  virtual int t() { return AB ? 1 : 2; }
};

template <bool AB2>
template <bool AB>
class AXX<AB2>: AX<AB> {
  virtual int t() { return AX<AB>::t() * 2 + (AB2 ? 1 : 2); }
}

...但是说真的，请只使用 RTTI。

Answer 3

我认为除了使用枚举（我认为这是一种完全合理的方法）之外，没有任何方法可以在编译时生成索引。我不确定模板是否会有帮助，因为模板纯粹是功能性的，除了模板类型本身的名称之外，没有地方可以存储任何全局状态（即当前索引）（这正是您正在尝试的）以避免）。

如果您确实想要整数 ID，那么在运行时设置它们可能是最简单的方法，而不是太努力。

首先，拥有一个表示类型的对象，并使用典型的手工 RTTI 方法：让每个类都有该对象的静态实例，并使其虚拟 get-type-in​​fo 函数返回指向该对象的指针。因此，每个类中都会有一些代码，如下所示：

static TypeInfo ms_type_info;
virtual const TypeInfo *GetTypeInfo() const {
    return &ms_type_info;
}

并且您将定义类型信息，将任何信息放入 <<无论您想要什么信息>> 部分TypeInfo 存储起来以使其比编译器的 RTTI 更好；

TypeInfo WhateverClass::ms_type_info(<<whatever info you want>>);

（我见过的每个实现都使用宏来自动创建这两个文本位；有点难看，但您的选择是有限的，而且它比键入它要好。）

TypeInfo struct 本身看起来有点像这样：

struct TypeInfo {
    int type_index;
    TypeInfo *next;
    TypeInfo(<<whatever>>) {<<see below>>}
};

如果读者更喜欢 get 和 set 函数，它可以有这些。

TypeInfo 对象对于类应该是静态的，而不是函数，因为其目的是创建所有 TypeInfos 的列表。这里你有两个选择。自动的方法是让上面留空的构造函数中的每个 TypeInfo 将自身添加到某种全局链表中；另一种是拥有一个大功能，可以手动将所需的内容添加到全局列表中。

然后，在启动时，运行 TypeInfo 对象并为每个对象分配一个索引。假设有一个 TypeInfo *g_first_type_info 指向列表中的第一个类型信息，类似这样的事情就可以做到：

int next_type_index=0;
for(TypeInfo *ti=g_first_type_info;ti;ti=ti->next)
    ti->type_index=next_type_index++;

现在，当您需要整数 ID 时，您可以轻松检索它：

object->GetTypeInfo()->type_index;

您可以实现 < code>t 现在很容易：

virtual int t() const {
    return ms_type_info.type_index;
}

完全公开我能想到的问题：

• 类型索引不是在编译时设置的，所以如果你构建数组，你需要在运行时构建它们。如果您的数组本来是编译时常量，那么这可能会浪费代码 - 但是对于不支持 C99 样式数组初始化语法的编译器，这有时会使代码更具可读性。

• 如果您想在 main 启动之前在全局构造函数中完成所有操作，您可能会遇到麻烦，因为 TypeInfo 对象只是普通的全局对象（无论如何在这种情况下） ) 无论如何，在分配类型索引之前都无法正确使用。

• 链接器倾向于删除似乎没有使用的全局对象，因此静态库中的类型信息对象可能永远不会将自己添加到列表中。因此，您应该记住，虽然自动注册方法运行良好，但当它不起作用时，它就不起作用，因此您最终可能不得不手动注册内容。

Answer 4

我已成功使用此处描述的方法：
http://www.flipcode.com/archives/Run_Time_Type_Information.shtml。基本上每个需要 RTTI 的类都有一个返回其 rtti 类型的静态函数。使用类型结构的优点是您可以向 rtti 结构添加函数。

我修改了此方法以允许诸如 component->IsOfType(CollisionComponent::GetClass()) 之类的操作。

我还扩展了 RTTI 结构以提供类名，现在我可以调用 component->IsOfType("CollisionComponent") 而无需包含 CollisionComponent.h。

当与这个动态类创建结合使用时，这种方法非常方便。我能够在脚本中创建和识别 C++ 类，并实例化大量不同的组件，这些组件仅在操作系统/硬件支持所需类型时才加载。我还可以根据服务器版本重新配置加载的组件类型。例如，一台服务器可以允许使用“CollisionComponent_V2_0”，而另一台服务器则强制使用“CollisionComponent_Proxy_V2”