对于特定的类层次结构，我需要知道基类引用是否是特定派生类的实例。
由于不同的原因，我这里不能使用标准的 C++ RTTI，我需要实现一个自定义的instanceof 机制。
LLVM-stle RTTI 可以满足我的需求，但我想知道它是否存在一种方法（以某种方式使用模板）来自动执行 classof 方法？
这种机制是否有其他/更简单的实现可以让我们知道基类是否是派生类的实例？
我的限制：
【问题讨论】：
get_class_id()这样的虚函数怎么样？
我想知道是否存在一种方法（以某种方式使用模板）来自动执行 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).
};
当然，您也可以将其扩展到多重继承，只需创建更多宏来注册类型。这个方案也有无数种变化（我个人在my implementation 中将类型注册到全局存储库并提供对工厂函数的访问权限）。
我认为没有任何实用的方法可以避免在您创建的每个类中都使用 MACRO 调用。我已经考虑了一段时间（前段时间，当我自己做的时候），我得出的结论是，最简单和最干净的解决方案是在课堂上进行 MACRO 调用（尽管我非常不屑于 MACRO 在一般的）。但我不知道，也许其他人对此有更好的（基于模板的）解决方案，不会造成太多混乱或不太干扰。多年来我一直在使用这个方案，它非常漂亮和干净。
我没有多重继承，但我有多个继承级别。
上述方案适用于任何级别的继承（即，它是一种可扩展的解决方案）。如果有一天您愿意，它也可以很容易地适应多重继承。
对内存占用的影响必须尽可能小
我知道 LLVM 更喜欢没有任何虚函数的解决方案，而是在基类中使用整数 ID 数据成员。使用这种方案（但可能）实现与上述相同的功能变得有点困难。使用虚拟函数要容易得多，它只占用一个指针（vtable 指针）的空间，该指针通常不比整数 ID 数据成员大多少。如果类已经是多态的，那么成本就完全没有了。而且，当然，上面的内容比内置的 C++ RTTI 轻得多。所以，除非你真的想压缩那些你可以用积分 ID（或枚举）解决方案节省的字节，否则我建议你使用基于虚拟函数的解决方案，就像我上面展示的那样。
无法进行动态分配。
一般不需要动态分配。只有更复杂（且功能丰富）的 RTTI 实现需要一些动态分配。如果您只想能够执行“classof()”（因此，动态转换），那么肯定不需要动态内存分配。
【讨论】：
您想要某种树状数据结构作为全局变量来存储您的类层次结构
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中找不到层次类，实现一个有点棘手，我不知道是否值得。
【讨论】：