如何动态广播没有虚拟方法的类的指针？

Question

I'm using the llvm library and I want to check if an llvm::Value * is actually an llvm::LoadInst * (llvm::LoadInst is inherited from llvm::Value).

But sadly, llvm::Value doesn't contain any virtual method! (Yes, even without virtual destructor) Is it possible to use dynamic_cast on a class without virtual methods, or is there any other way to do the type checking?

Answer 1

In LLVM, there is a llvm::dyn_cast<T> that will use LLVM's internal constructs to dynamically cast from one type to another, as long as they are indeed valid casts - if you use the wrong type T , it will return a nullptr .

So something like:

llvm::Value *v = ... some code here ... 
...
llvm::LoadInst* li = llvm::dyn_cast<llvm::LoadInst>(v);
if (!li) { ... not a LoadInst, do whatever you should do here ... }
else { ... use li ... }

Naturally, if you already DO know that v is a LoadInst , you don't need to check - but an assert(li && "Expected a LoadInst"); will catch if you ever got that wrong.

Note that you don't use T* for llvm::dyn_cast<T> , as you would for the C+++ standard dynamic_cast .

This comment in the code for llvm::Value explains that there is no vtable exactly for this reason ( http://www.llvm.org/doxygen/Value_8h_source.html#l00207 )

   /// Value's destructor should be virtual by design, but that would require
   /// that Value and all of its subclasses have a vtable that effectively
   /// duplicates the information in the value ID. As a size optimization, the
   /// destructor has been protected, and the caller should manually call
   /// deleteValue.
   ~Value(); // Use deleteValue() to delete a generic Value.

Answer 2

Is it possible to use dynamic_cast on a class without virtual methods,

There is no way to use dynamic_cast if the input is not pointer or reference to a polymorphic type, ie does not have any virtual member functions.

or is there any other way to do the type checking?

I can't think of any. Your best option is to use static_cast but then you must be very certain that the type to which you are casting is valid.

struct Base { ... };
struct Derived1 : Base { ... };
struct Derived2 : Base { ... };

void foo(Base* base)
{
    Derived1* ptr = static_cast<Derived1*>(base);
    // Use ptr
}

void bar()
{
    foo(new Derived1()); // OK.
    foo(new Derived2()); // Not OK since foo assumes that the pointer 
                         // really points to a Derived1 object.
}