`dynamic_cast`从Base到Derived

Question

Yes, I know that downcast using dynamic_cast can't compile if the Base is not polymorphic, but my problem is not about this.

class Base {
    public:
        virtual void bar()
        {
            cout << "bar\n";
        }
};

class Derived: public Base {
    public:
        void foo()
        {
            cout << "foo\n";
        }
};

int main()
{
    Base *pb;
    Derived *pd;

    pb = new Derived;  //Base* points to a Derived object
    pd = dynamic_cast<Derived*>(pb); 
    pd->foo();  //outputs foo

    pb = new Base;  //Base* points to a Base object
    pd = dynamic_cast<Derived*>(pb);  
    pd->foo();  //outputs foo, too. Why?
}

I thought when pb = new Derived; , pb actually points to a Derived object lies in heap. After pd = dynamic_cast<Derived*>(pb); , pd also points to that Derived object, so pd->foo() should be OK.

But when pb = new Base; , what pb points to is a Base object in heap, then after pd = dynamic_cast<Derived*>(pb); , how could pd->foo() works? Did dynamic_cast turn the Base object in heap into a Derived object?

Answer 1

In C++, each instance of a class has its own version of datatypes, but all classes share the same function in memory (other than for inline functions). In your case, when you say something like:

pd->foo();

You are essentially calling Derived::foo , which is a function in memory and the compiler knows where it is. The thing is, it is not dependent on pd at all. However, if you had something like this:

class Derived : public Base {
    private:
        int a;

    public:
        Derived() { a = 100; }

        void foo() {
            std::cout<<a<<std::endl;
        }
 };

Then, pd->foo() will cause a Segmentation fault. Here, your dynamic cast has failed and when Derived::foo is called, it is passed 0 as the this object. It was fine in the previous case, as the this object was never used. However, in the second case, it is used and hence, causes a Segmentation fault.

Answer 2

In your foo you don't access this , which in this case should be NULL . That is what dynamic_cast returns when the cast cannot be done.

Basically you're in the "undefined behavior" area here.

Answer 3

You're running into undefined behavior. You should check the return type of dynamic_cast .

pd = dynamic_cast<Derived*>(pb);  

This returns null, and you call a function on a NULL pointer. Anything can happen.

Answer 4

Please always prefer to check whether the cast is successful before trying to use it. I guess its the advantage of using casting. You can check whether its successful or not.

pd = dynamic_cast<Derived*>(pb);  
if(pd!=NULL)
  pd->foo();

If the cast fails pd has value NULL. Do not use pd unless you are sure it has a value. and then only de reference it