Kann jemand dieses Verhalten für die virtuelle Funktion erklären?

Question

Ich weiß über das Grundkonzept der virtuellen Funktion und Laufzeitanruf. Aber ich versuchte einig Stück Code ausgeführt wird, die mir

verwirrte

class A { 
    public: 
    A& operator=(char) { 
     cout << "A& A::operator=(char)" << endl; 
     return *this; 
    } 
    virtual A& operator=(const A&) { 
     cout << "A& A::operator=(const A&)" << endl; 
     return *this; 
    } 
    }; 

    class B : public A { 
    public: 
     B& operator=(char) { 
     cout << "B& B::operator=(char)" << endl; 
     return *this; 
     } 

     virtual B& operator=(const B&) { 
     cout << "B& B::operator=(const B&)" << endl; 
     return *this; 
     } 
    }; 

    int main() { 
    B b1; 
    B b2; 
    A* ap1 = &b1; 
    A* ap2 = &b1; 
    *ap1 = 'z'; 
    *ap2 = b2; 
    } 

Das Ausführen dieses Programms geben Sie mir die folgende Ausgabe: -

A& A::operator=(char) //expected output 
    A& A::operator=(const A&) //Why this Output? in case of *ap2 = b2; 

b2 ein Objekt von B Typ, aber noch geht es in virtuellen A& operator=(const A&) und nicht virtuell B& operator=(const B&). Warum ist das so ?

Answer 1

Weil virtual B& operator=(const B&) nicht übersteuert virtual A& operator=(const A&); Die Argumente sind anders.

Answer 2

Damit eine abgeleitete Klassenfunktion die Base-Klassenfunktion überschreiben kann, muss die abgeleitete Klassenfunktion genau denselben Funktionsprototyp haben (Ausnahme: kovariante Rückgabetypen sind zulässig).

Der = Operator in abgeleiteten Klasse B hier nicht über gleiche Funktion Prototyp wie = in Basisklasse A, und daher ist es nicht die Basisklasse = außer Kraft setzen.

Der einzige verfügbare Operator = ist derjenige, der aufgerufen wird.

Answer 3

Damit eine Funktion als Überschreibung betrachtet werden kann, muss die Signatur exakt mit der Version in der Basisklasse übereinstimmen (der Rückgabetyp kann kovariant sein, wenn ein Zeiger oder eine Referenz zurückgegeben wird). Das heißt, Sie müssten

B& B::operator= (A const&) 

definieren, um die Version von der Basisklasse zu überschreiben. Beachten Sie, dass es für Eingabeparameter in überschreibenden Funktionen nicht sinnvoll ist, kovariant zu sein, da Sie nicht garantieren können, dass die Basisklassenversion mit einem abgeleiteten Objekt in einem Kontext aufgerufen wird, der nur die Basisklasse verwendet. Wenn Parameter zu einer überschreibenden Funktion kontravariant sein könnten, unterstützt C++ dies nicht.

Answer 4

Hier in der abgeleiteten Klasse nimmt die Funktion B, während in der Basisklasse die Annahme von A. So, im Grunde ist es nicht überschrieben, da die Funktion Argumente sind unterschiedlich.

Beachten Sie auch, dass der Rückgabetyp im Falle einer Außerkraftsetzung anders sein kann, da in Ihrem Fall die Referenz von A in der Basis und die Referenz von B in abgeleitet sind. virtuelle Basis & func (konst Basis &) virtuellen Abgeleitet & func (konst Basis &) Dies gilt Form des überwiegenden