Question

对于特定的类层次结构，我需要知道基类引用是否是特定派生类的实例。出于不同的原因，我不能在这里使用标准C ++ RTTI，我需要实现自定义instanceof机制。

LLVM-stle RTTI可满足我的需求，但我想知道它是否存在（以某种方式使用模板）自动执行classof方法？

是否有其他/更简单的实现这种机制，可以知道基类是否是派生类的实例？

我的约束：

我没有多重继承，但我有几个级别的继承。
对内存占用的影响必须尽可能小，并且无法执行动态分配。

Answer 1

我想知道它是否存在某种方式（以某种方式使用模板）来自动化类方法的实现？

是的，有一些方法可以自动化classof方法，我真的不明白为什么LLVM页面会演示一组手动滚动的类方法，因为如果你自动化这个非常简单的过程它会更加可扩展。

这是一个非常基本的解决方案：

class TypedObject {
  public:
    virtual ~TypedObject() { };

    virtual int getClassId() const { return 0; };
    static int getStaticClassId() { return 0; };

    virtual bool isOfType(int aID) const { return (aID == 0); };

    template <typename T>
    bool isOfClass() const { return isOfType( T::getStaticClassId() ); };

};

运行时强制转换（即dynamic_cast）函数如下所示：

template <typename T>
T* runtime_ptr_cast(TypedObject* p) {
  if( (p) && (p->isOfClass<T>()) )
    return static_cast<T*>( p );
  return NULL;
};

template <typename T>
typename std::enable_if< 
  std::is_const< T >::value,
T* >::type runtime_ptr_cast(const TypedObject* p) {
  if( (p) && (p->isOfClass<T>()) )
    return static_cast<T*>( p );
  return NULL;
};

然后，您需要的只是MACRO来自动创建虚拟和静态函数：

#define MY_RTTI_SYSTEM_CREATE_TYPE_1_BASE( NEWCLASSID, BASECLASSNAME ) \
  public: \
    virtual int getClassId() const { return NEWCLASSID; }; \
    static int getStaticClassId() { return NEWCLASSID; }; \
     \
    virtual bool isOfType(int aID) const { \
      return ((aID == NEWCLASSID) || BASECLASSNAME::isOfType(aID)); \ 
    };

然后，您可以创建一个这样的新类：

class Foo : public TypedObject {

  // ... some code, as usual ...

  // call the macro with a given ID number and the name of the base-class:
  MY_RTTI_SYSTEM_CREATE_TYPE_1_BASE(1, TypedObject)
};

导致：

int main() {
  Foo f;
  TypedObject* b = &f;

  // check the type:
  if( b->isOfClass<Foo>() ) 
    std::cout << "b is indeed for class Foo!" << std::endl;

  // make a dynamic cast:
  Foo* pf = runtime_ptr_cast<Foo>( b );
  if( pf )
    std::cout << "cast to 'Foo*' was successful!" << std::endl;

  const TypedObject* cb = b; 
  const Foo* cpf = runtime_ptr_cast<const Foo>( cb );
  if( cpf )
    std::cout << "cast to 'const Foo*' was successful!" << std::endl;

  Foo* pf2 = runtime_ptr_cast<Foo>( cb ); // ERROR: no such function (invalid cast).
};

当然，您也可以通过创建更多MACRO来注册类型来将其扩展为多重继承。这个方案也有无数的变化（就个人而言，在my implementation中，我将类型注册到全局存储库并且也可以访问工厂函数。）

我认为没有任何实际的方法可以避免在您创建的每个类中使用MACRO调用。我已经考虑了一段时间（前段时间，因为我自己制作）并且我得出结论，最简单和最干净的解决方案是在课堂上进行MACRO调用（尽管我对MACROs有很大的蔑视）一般）。但我不知道，也许其他人有一个更好的（基于模板的）解决方案，这不会导致太多的混乱或不是太介入。我已经使用这个方案多年了，它非常干净。

我没有多重继承，但我有几个级别的继承。

上述方案适用于任何继承级别（即，它是可扩展的解决方案）。如果有一天你想这样做，它也可以很容易地适应多重继承。

对内存占用的影响必须尽可能小

我知道LLVM更喜欢没有任何虚函数的解决方案，而是在基类中使用整数id数据成员。使用这种方案实现与上述相同类型的功能变得有点困难（但可能）。使用虚函数要容易得多，虚函数只占用一个指针（vtable指针）的空间，这通常不比整数id数据成员大。如果类已经是多态的，那么成本就没有了。当然，上面的内容比内置的C ++ RTTI轻得多。所以，除非你真的想用一个整数id（或枚举）解决方案来挤出你可以备用的那几个字节，我建议你选择一个基于虚拟函数的解决方案，如上所示。

无法执行动态分配。

一般不需要动态分配。只有更复杂（和功能丰富）的RTTI实现才需要一些动态分配。如果你想要的只是能够做“classof（）”（因此，动态转换），那么肯定不需要动态内存分配。

Answer 2

您希望将某种类型的树（如数据结构）作为全局变量来存储类层次结构

class Foo : public Foo_Parent {
  IS_PART_OF_HIERARCHY

public:
  Foo();
  ...
}

#define IS_PART_OF_HIERARCHY
  private:
    static Hierarchy<string> *node;
  public:
    bool isChildOf( string parent ) const;
    bool isParentOf( string child ) const;

在.cpp文件中

INSERT_INTO_HIERARCHY( Foo, Foo_Parent )

Foo::Foo() {}
....

#define INSERT_INTO_HIERARCHY( class_name, parent_class_name )
  Hierarchy<string> class_name::node = classes_hierarchy.insertAfter( #parent_class_name );
  bool class_name::isChildOf const( string ) {
      auto *node = class_name::node;
      // traverse the parents of node
  }
  bool class_name::isParentOf const( string ) {
      auto *node = class_name::node;
      // traverse the children of node
  }

我在STL中找不到层次结构类，实现一个层次结构很难，我不知道是否值得付出努力。

自动化LLVM样式的RTTI代码

2 个答案: