Should static_cast<Derived *>(Base pointer) give compile time error?

Question

class A
{
 public:
 A()
 {

 }
};

class B : public  A
{
 public:
 B()
 {
 }
};

int main()
{
A *a=new A();
B * b=static_cast<B*>(a);
}

Answer 1

It doesn't give a compile time error because the cast could very-well be valid, and you would often do it in practice, e.g.:

A* a = new B;
B* b = static_cast<B*>(a); // OK

In your code, as far as the compiler is concerned, you are doing the same thing. It cannot know that the cast would be invalid, so it allows it at compile time. At run time however, you're going to get some nasty errors as soon as you try to use a feature of B on an instance of A.

Answer 2

It cannot give compile time error because a Base-Derived relationship can exist at runtime depending on the address of the pointers being casted. static_cast always succeeds, but will raise undefined-behavior if you don't cast to the right type. dynamic_cast may fail or not, actually telling you whether you tried to cast to the right type or not.

So in my opinion, static_cast should be used to downcast only if the design can establish that such a possibility exists. One good example of this is CRTP. So it is logical in some situations but try to avoid it as it is undefined-behavior.

RTTI is not needed for static_cast which might make it theoretically faster, but I will anytime trade-in a dynamic_cast against the undefined behavior that static_cast may cause!