Wie funktioniert die Erbschaft hier?

Question

Ich weiß nicht genau, wie der Code funktioniert. Wie A c0 = neue C(); * sogar funktionieren? Wie kann ich ein Zeiger 'A' Objekt von einem 'C' machen?

class A { 
public: 
    A() { print("Constructor of A"); } 
    virtual ~A() { print("Destructor of A"); } 
}; 

class B : public A { 
public: 
    B() { print("Constructor of B"); } 
    ~B() { print("Destructor of B"); } 
}; 

class C : public B { 
public: 
    C() { print("Constructor of C"); } 
    ~C() { print("Destructor of C"); } 
}; 

int main() { 
    print("A* = C"); 
    A* c0 = new C(); 
    delete c0; 

    print("B* = C"); 
    B* c1 = new C(); 
    delete c1; 

    print("C* = C"); 
    C* c2 = new C(); 
    delete c2; 

    return 0; 
} 

Ich dachte, ich vor, das Erbe eine lange Zeit verstanden, aber jetzt, wenn ich es zu benutzen, brauche ich habe gerade im Code verloren.

Answer 1

Da C erbt von B, die von A erbt, erbt C indirekt aus A. Daher ist jede Instanz von C auch eine Instanz von A. Daher kann ein Wert vom Typ C* direkt in einen Wert vom Typ A* konvertiert werden.

Answer 2

Willkommen bei der Vererbung !! Continuous inheritence Hierarchie spricht die Wahrheit ..

************************************* 
A Base 
B Base + (Something) 
C Base + (Something) + (Something) 
************************************** 

wie das obige Bild Denken Sie daran, .. so jetzt können Sie sehen, dass C die Basis enthält, die absolut A selbst .. so das Ding funktioniert sie ..

Answer 3

Da ein C von A abgeleitet ist, sind alle C-Objekte (isA) A's. Der neue Operator erzeugt ein C, und da ein C "isA" A ist, kann er einem A * -Zeiger zugewiesen werden.

wenn ein A * Zeiger verwenden, können Sie nur Funktionen aufrufen, die in der Klasse A definiert sind

(weil der Zeiger-Typ ein A ist)

Wenn Sie einen C * Zeiger auf ein Objekt C haben, können Sie Rufen Sie eine der Funktionen in A, B oder C auf (vorausgesetzt, sie sind öffentlich oder geschützt).

Wenn Sie eine virtuelle Funktion "f", und eine nicht-virtuelle Funktion "g" definiert in jeder der Klassen und die folgenden Aufgaben:

A * pA = new A; A * pAC = neues C; C * pC = neues C;

dann,

PA-> f() eine :: f() aufrufen; pA-> g() wird A :: g();

pAC-> f() wird A :: f(); pAC-> g() wird C :: g();

pC-> f() wird C :: f(); pC-> g() wird C :: g();

Beachten Sie, dass der wirkliche Bereich von Interesse in dem PAC-Beispiel ist. Der Aufruf der virtuellen Funktion ruft immer die Implementierung des aktuellen Objekts auf. Rufen Sie die plain-Funktion auf, rufen Sie die Implementierung auf der Grundlage des Zeigertyps auf.