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

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

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

我的约束:

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

最佳答案

I was wondering if it would exists a way (somehow using templates) to automate the implementation of the classof method?

是的，有很多方法可以使 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).
};

当然，您也可以将其扩展到多重继承，只需创建更多用于注册类型的宏。此方案还有无数种变体(就我个人而言，在 my implementation 中，我将类型注册到全局存储库并提供对工厂函数的访问权限)。

我认为没有任何实用的方法可以避免在您创建的每个类中使用 MACRO 调用。我已经考虑了一段时间(前段时间，当我自己做的时候)并且我得出结论，最简单和最干净的解决方案是在类中进行宏调用(尽管我非常不屑于在类中调用宏)一般的)。但我不知道，也许其他人有更好的(基于模板的)解决方案，不会造成太多困惑或不太干扰。我多年来一直在使用这个方案，它非常漂亮干净。

I don't have multiple inheritance but I have several level of inheritance.

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

Impact on memory footprint must be as minimal as possible

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

it is not possible to perform dynamic allocation.

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

关于c++ - 自动化 LLVM 风格的 RTTI 代码，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15814775/