4

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

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

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

我的限制：

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

2 回答 2

4

我想知道是否存在一种方法（以某种方式使用模板）来自动执行 classof 方法？

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

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

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;
};

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

#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 调用。我已经考虑了一段时间（前段时间，当我自己做的时候），我得出结论，最简单和最干净的解决方案是在课堂上进行 MACRO 调用（尽管我非常不屑于 MACRO 在一般的）。但我不知道，也许其他人对此有更好的（基于模板的）解决方案，不会造成太多混乱或不太干扰。我多年来一直在使用这个方案，它非常漂亮和干净。

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

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

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

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

无法执行动态分配。

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

于 2013-04-04T16:23:50.700 回答
0

您想要某种树状数据结构作为全局变量来存储您的类层次结构

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中找不到层次类，实现一个有点棘手，我不知道是否值得努力。

于 2013-04-04T18:10:03.193 回答