Alternatives to dynamic_cast in class hierarchy

Question

I have a class structure with loads of different child classes all inheriting from the same abstract base class. This base class is there because all these classes self register at compile time to a factory from which they are built. This is really neat and keeps me from the burden of maintaining a huge switch or any other flow mechanism somewhere down stream.

              +---------------+
              |     Base      |
              +--+---------+--+
                 |         |
         +-------+-+     +-+-------+
         |  Kid1   |     |  Kid2   |
         +----+----+     +----+----+
              |               |
  +---+---+---+               +---+---+---+
  |   |   |   | ...           |   |   |   | ....

However, these Kid1 and Kid2 classes are different and the issue is that I have to distinguish between them somewhere in my code and the only thing I have is a Base pointer. I did not want to bother the factory with this and keep that as simple as possible.

The way I solved this right now is by having Base being somewhat aware of the two siblings. It has a virtual method type() which returns an enum type distinguishing between Kid1 and Kid2. Both kids override this (basically saying I am KidX) such that I know with whom I am dealing. This type is then used to dynamic_cast Base to either of the kids and the program proceeds.

However, is this the right approach?

I could for example add some more virtual methods to base, on the one hand polluting it with methods only one part of the hierarchy uses but on the other hand saving me the dynamic_cast.

Any thoughts?

Answer 1

In multiple inheritance, dynamic_cast will shift the pointer as necessary and is a must. Therefore, getting rid of it is dangerous. If your system extends to a point where it uses MI somewhere down, you might get all sorts of strange behaviour.

Answer 2

You don't need dynamic_cast, dynamic_cast already use internal runtime type information to determine if it's able to cast the passed pointer/reference to the desired type but you are already checking it through the type() method. A static_cast is enough in your situation, as you are already providing RTTI by yourself.

Or alternatively you could just remove the type() method and use directly dynamic_cast, which yields nullptr if it's not able to cast the object to your desired type.

If you really want to avoid such things then you are forced to encapsulate the behavior desired into virtual methods such that wherever you need to use a Kid1 or Kid2, you will have different implementation without the need to really distinguishing between the two, just by letting polymorphism do its work.

Answer 3

You could try the Visitor pattern.

When should I use the Visitor Design Pattern?

Answer 4

Maybe you could use typeid operator. Because:

N3337 5.2.8/2 says:

When typeid is applied to a glvalue expression whose type is a polymorphic class type (10.3), the result refers to a std::type_info object representing the type of the most derived object (1.8) (that is, the dynamic type) to which the glvalue refers ....

Example:

struct Base
{
    virtual void f(){} //to ensure that Base is polymorphic object
};

struct Derived: Base{};

struct AnotherDerived: Base{};



int main()
{
    Base *ptr = new AnotherDerived;

    if(typeid(*ptr) == typeid(Derived)) //Do not forget to dereference pointer, otherwise typeid() will return type_info for pointer itself
    {
         cout << "ptr is pointing to object of type Derived" << endl;
    }

    if (typeid(*ptr) == typeid(AnotherDerived))
    {
        cout << "ptr is pointing to object of type AnotherDerived" << endl;
    }

}

However if you have to distinguish between them in your code why are you using pointer to Base? What about separating code where you are using only Base properties and code where are you using specific properties of your child classes? That's the whole point of polymorphism.

EDIT: As davmac pointed out. It will work only if these subclasses will be most derived classes.

Answer 5

I generally prefer to be able to get a handle to the desired type without using a cast. This means adding methods to the Base class:

virtual Kid1 *asKid1()
{
    return null;
}

virtual Kid2 *asKid2()
{
    return null;
}

The subclasses then override these as appropriate:

// (in Kid1)
virtual Kid1 *asKid1() override
{
    return this;
}

Although your Base class is still being "polluted" with extra methods, only these two methods are required, even if the subclasses are expanded in the future.

(You can have them return references rather than pointers, in which case they should throw an exception by default).