Abgeleitete Zeiger auf Basiszeigerkonvertierung mit statischem_cast, dynamic_cast oder expliziter Konvertierung rufen die Basisfunktion nicht auf

Question

Ich habe den folgenden Code.

#include <iostream> 
using namespace std; 


class Base 
{ 
public: 
    virtual int f(){cout<<"Base"<<endl;} 
}; 

class Derived:public Base 
{ 
public: 
    int f(){cout<<"Derived"<<endl;} 
}; 

int main() 
{ 
    Base b; 
    Derived d; 

    b.f(); ///base 
    ((Base)d).f(); ///base 

    cout<<"----------------"<<endl; 

    Base *b1 = new Base; 
    Base *b2 = new Derived; 
    Derived *d1 = new Derived; 

    b1->f(); ///base 
    ((Base*)d1)->f(); ///derived 
    ((Base*)b2)->f(); ///derived 
    static_cast<Base*>(d1); 
    d1->f();///derived 
    static_cast<Base*>(b2); 
    b2->f();///derived 

    cout<<"----------------"<<endl; 

    Base *b5 = dynamic_cast<Base*>(b2); 
    Base *b6 = dynamic_cast<Base*>(d1); 
    if(b5) 
     b5->f(); ///derived 
    if(b6) 
     b6->f(); ///derived 


    return 0; 
} 

Ich mag, warum die abgeleiteten * d1 OR b2 Zeiger, wenn an eine Basis mit expliziter Besetzung (Basis), statischen Guss (static_cast (d1)) oder dynamische Umwandlung (dynamic_cast (d1)) umgewandelt fragen Die Funktion f() der Basisklasse wird nach der Konvertierung nicht aufgerufen. Es scheint die f() - Funktion von der abgeleiteten Klasse jedes Mal aufzurufen.

Auch seltsam, wenn ich die Objekte auf diese Weise deklarieren. Die Konvertierung funktioniert und ruft die Basisfunktion auf.

Base b; 
    Derived d; 

    b.f(); ///base 
    ((Base)d).f(); ///base 

Nun verstand ich, dass der richtige Weg, um die f() von Basisklasse d->Base::f() wäre zugreifen, aber warum soll ich dynamic_cast oder static_cast verwenden, da sie die abgeleiteten Zeiger auf Basis und rufen die nicht konvertieren richtige Funktion. Ich würde, wenn möglich, eine detaillierte Erklärung benötigen. Vielen Dank!

Answer 1

Zum Glück für Sie und meine Tastatur, die Erklärung ist trivial:

((Base)d)Scheiben das Objekt d auf einen Wert kopiert Base Instanz.

((Base*)d1)->f() wird immer noch die abgeleitete Methode, da Base anrufen und somit Derived sind polymorph Typen, und obwohl ein ((Base*)d1)Base* Zeiger sind, er zeigt auf ein Objekt Derived. Dito für static_cast und dynamic_cast.

Referenz: https://en.wikipedia.org/wiki/Object_slicing