2

The class is polymorphic. Why do both print the same output?

class A
{
public:
    virtual void P(){ cout << "A" << endl; }

};
class B : public A
{
public:
    void P()override{
        cout << "B" << endl;
    }
    B(){ cout << "Created B" << endl; s = "Created by B"; }
    string s;
};

And main: Variant 1:

A* a = new B();    // Created B
B* b = static_cast<B*>(a);
b->P();    B
cout<<b->s<<endl;  // Created by B

And variant 2:

A* a = new B();
    B* b = dynamic_cast<B*>(a);
    if (b){
        b->P();
        cout << b->s << endl;  // Prints same
    }
GreenAsJade
  • 14,459
  • 11
  • 63
  • 98
Person.Junkie
  • 1,816
  • 4
  • 21
  • 31

2 Answers2

8

Both of your examples will do the same thing, and that's fine. Try with this instead:

A* a = new A();

In this case, the static_cast will "succeed" (though it is undefined behavior), whereas the dynamic_cast will "fail" (by returning nullptr, which you already check for).

Your original examples don't show anything interesting because they both succeed and are valid casts. The difference with dynamic_cast is that it lets you detect invalid casts.

If you want to know how dynamic_cast does this, read about RTTI, Run Time Type Information. This is some additional bookkeeping that C++ does in certain cases to inspect the type of an object (it's important for this and also if you use typeid()).

John Zwinck
  • 239,568
  • 38
  • 324
  • 436
  • why is important virtual function for using dynamic_cast? – Person.Junkie Oct 04 '14 at 07:43
  • @Gui_C: I don't understand what you're asking now. – John Zwinck Oct 04 '14 at 07:44
  • I can not use dynamic_cast if there is no least one virtual function. and why? :) – Person.Junkie Oct 04 '14 at 07:49
  • 1
    @Gui_C: Oh I see what you mean. That's because classes with no virtual functions have no virtual table (because of the C++ philosophy of "only pay for what you use"). But the virtual table is how the RTTI stuff is implemented. For more, see here: http://stackoverflow.com/a/4227691/4323 – John Zwinck Oct 04 '14 at 08:02
  • This link also explains it pretty well. http://stackoverflow.com/questions/8850044/why-base-to-derived-dynamic-casting-is-only-allowed-for-polymorphic-classes/8850101#8850101 – Rndp13 Jun 03 '15 at 12:15
1

In this case, static_cast is semantically equivalent to dynamic_cast.

static_cast < new_type > ( expression )

2) If new_type is a pointer or reference to some class D and the type of expression is a pointer or reference to its non-virtual base B, static_cast performs a downcast. Such static_cast makes no runtime checks to ensure that the object's runtime type is actually D, and may only be used safely if this precondition is guaranteed by other means, such as when implementing static polymorphism. Safe downcast may be done with dynamic_cast.

dynamic_cast < new_type > ( expression )

5) If expression is a pointer or reference to a polymorphic type Base, and new_type is a pointer or reference to the type Derived a run-time check is performed:

a) The most derived object pointed/identified by expression is examined. If, in that object, expression points/refers to a public base of Derived, and if only one subobject of Derived type is derived from the subobject pointed/identified by expression, then the result of the cast points/refers to that Derived subobject. (This is known as a "downcast".)

[...]

c) Otherwise, the runtime check fails. If the dynamic_cast is used on pointers, the null pointer value of type new_type is returned. If it was used on references, the exception std::bad_cast is thrown.

The last clause is what makes dynamic_cast safer, as you can check if the cast was unsuccessful:

Base* b1 = new Base;
if(Derived* d = dynamic_cast<Derived*>(b1))
{
    std::cout << "downcast from b1 to d successful\n";
    d->name(); // safe to call
}