Base class handle to child class instance. Is there an elegant way to get the child class type at runtime?

Question

This is how I do it currently:

ref class Base abstract {};
ref class ConcreteClass1 : public Base {};
ref class ConcreteClass2 : public Base {};
(...and even more...)

void DoStuff(Base ^base)
{
   System::Type ^type = base->GetType();
   System::String ^name = type->Name;

   if(name == "ConcreteClass1")
          DoOtherStuff((ConcreteClass1 ^) base);
   else if(name == "ConcreteClass2")
          DoOtherStuff((ConcreteClass2 ^) base);
   (...and even more...)
}

Is there a more "elegant" way to do this?

With my approach, I have to add a new else if for every new Concrete Class, which makes me feel like one of the examples on thedailywtf.com.

Answer 1

Well, one simple thing you could do to make this more elegant would be to compare the types directly instead of using strings and type names:

void DoStuff(Base ^base)
{
   System::Type ^type = base->GetType();

   if(type == ConcreteClass1::typeid)
          DoOtherStuff((ConcreteClass1 ^) base);
   else if(type == ConcreteClass2::typeid)
          DoOtherStuff((ConcreteClass2 ^) base);
   (...and even more...)
}

However, this has quite a bit of "code smell" to it. Typically, the entire point of using abstract classes is to allow for polymorphism - if you can make DoOtherStuff a virtual function on each type, you could just do:

base->DoOtherStuff();

And the appropriate method will get called for you...

Answer 2

It is more elegant if your design confines all the knowledge about what makes a ConcreteClass1 special inside ConcreteClass1. Could you have a Process() function in the base class that they each inherit from the base, and have it just do whatever your if bodies would do, including calling DoOtherStuff(this) ? That would have better encapsulation, and when you added more classes you wouldn't change your calling code, because it would just be calling base->Process() and relying on polymorphism.

Answer 3

A better design than if statements, I find, is to use a dispatch table -- essentially a Dictionary from 'type' to function pointer / delegate. If the child class is responsible for registering itself to the table, then your dispatch function is simply something like :

void DoStuff(Base ^base)
{
    System::Type ^type = base->GetType();
    m_DispatchTable[type](base);
}

and to add a new dispatch, it just needs to register itself in the table - no code updating required. This avoids maintaining the 'if' aggregate, and if you ever need to call more than one function you can make your dispatch table map to a more complex type.