Question

I have some code that behaves like this:

class Base {};

class MyClass : public Base {};

MyClass* BaseToMyClass(Base* p)
{
  MyClass* pRes = dynamic_cast<MyClass*>(p);
  assert(pRes);
  return pRes;
}

Is there a way to add a compile time check so I can catch calls to this function where p is not an instance of MyClass? I had a look at Alexandrescu’s SUPERSUBCLASS function but I’m not sure if it can do the job.

Thanks!

Answer 1

Is there a way to add a compile time check so I can catch calls to this function where p is not an instance of MyClass?

Generally, if you want to check this at compile-time, you’d take the derived class as an argument.

However, if the only thing you have is a Base* or a Base&, then you cannot know whether it refers to a MyClass object. It’s the very nature of run-time polymorphism that this is to be found out at run-time. This check can only be done where the MyClass object/reference/pointer is converted to a Base*/Base&. That’s why dynamic_cast<>() was invented.

Your function basically is a safe_cast. If you put it into the right syntax, it looks like this:

template< typename Derived, typename Base >
inline Derived* safe_cast(Base* pb)
{
  #if defined _NDEBUG
    return static_cast<Derived*>(pb);
  #else
    Derived* pd = dynamic_cast<Derived*>(pb);
    assert(pd);
    return pd;
  #endif
}

template< typename Derived, typename Base >
inline Derived& safe_cast(Base& rb)
{
  return *safe_cast<Derived*>(&rb);
}