bin gerade (mal wieder) am C++ lernen für die kommende Klausur am Donnerstag. Es werden wenige Aufgaben zum Selberprogrammieren drankommen, dafür sehr viel Verständniskram - und das auf einem relativ hohen Level.

Und genau bei Letzterem hakt es gerade. Folgende Aufgabe wurde in einer Klausur der letzten Jahren gestellt:

class Koerper {
public:
   int el;                  // Teil c)
   Koerper() { el = 5; cout << el; }
   void f(int i) {i = i + el; el = i; cout << getel(); }
   int getel() {return el;}                              // Z6
}
class Kugel : public Koerper {
public:
   int getel() {return (el-4);}
};

Das zugehörige Hauptprogramm:

int main() {
  Koerper k1;            // 5 / 5
  Koerper* k2;           // 
  Kugel k3;              // 5 / 5
  cout << k3.getel();    // 1 / 1
  k1 = k3;               //
  cout << k1.getel();    // 5 / 5
  k2 = &k3;              // 
  cout << k2->getel();   // 5 / 1
  k2->f(0);              // 5 / 1
}

Tragen Sie die Ausgaben zeilengenau in die vorbereiteten Tabellen ein. In die linke Tabelle kommen die Ausgaben unter Verwendung der Originalklassen und in die rechte Tabelle die Ausgaben, wenn die Funktion getel in Zeile 6 virtuell wäre.

So, ich hoffe, ich hab's einigermaßen nachvollziehbar hingeschrieben. Die Kommentare im Hauptprogramm sind die Lösungen von Teil a) / b) bzw. getel nicht virtuell / getel virtuell.

Bisher dachte ich, dass die Faustregel für virtuelle Funktionen in etwa diese ist: "Gibt es in Basisklasse und abgeleiteter Klasse eine Funktion gleichen Namens mit gleicher Signatur, so wird stets die Funktion der Basisklasse aufgerufen, auch wenn man eigentlich auf die der abgeleiteten zugreifen will. Um Letzteres wirklich zu erreichen, muss man die Funktion virtual deklarieren."

Das scheint nun so nicht zu stimmen, auch wenn dies die einzige Aufgabe dieser Art war, bei der die Faustregel nicht anwendbar war. Und jetzt endlich mal zu den eigentlichen Verständnisfragen :

a) Die Zeile k1 = k3 im Hauptprogramm verstehe ich nicht vollständig. Da wird aus einem Körper mittels impliziter Typumwandlung eine Kugel gemacht, so weit, so gut. Aber was passiert da genau? Welches getel habe ich nachher in k1 drinstehen (überschrieben ja/nein?)

b) Welchen Unterschied im Bezug auf virtuelle Funktionen macht es genau, ob ich nun mit (k2->getel) oder ohne (k3.getel) arbeite?

b) k1 und k3 sind Objekte im SPeicher, keine Referenzen/Pointer. wenn du eine Funktion direkt auf k1 oder k3 aufrufst (k1.getel()) wird auch immer Koerper::getel() (k1) bzw. Kugel::getel() (k3) aufgerufen, jenachdem als was k1/k3 deklariert wurde! Egal ob getel jetzt virtual oder nicht deklariert ist.
k2 hingegen ist ein Pointer. hier wird beim Dereferenzieren geschaut ob ne virtuelle Tabelle (oder was auch immer dein Compiler erstellt, wenn "virtual" auftaucht) existiert. existiert diese, wird der genaue Typ des referenzierten Objekts ermittelt. In deinem Beispiel in Zeile 8 ist das eine Kugel. Somit wird - falls virtual - Kugel::getel() aufgerufen. Falls getel nicht virtual ist, ist es Koerper::getel() - k2 ist deklariert als "pointer auf Koerper".

In der nächsten Zeile k2 = &k3 wird lediglich die Adresse mit hilfe des Adressoperatos '&' zugewiesen, d.h. das Abgeleitete Objekt ist immernoch die Kugel und hier kommt das virtual in Spiel.

Der Compiler merkt sich das k2 ein Pointer vom Typ Koerper ist, aber er merkt sich auch, dass k3 vom Typ Kugel ist. Das virtual bewirkt, dass die Funktion der Abgeleiteten Klasse nun bevorzugt aufgerufen wird.

Neue Faustregel:
"Man verwendet virtual dann wenn man davon ausgeht, dass die erbenden Klassen die Funktion überschreiben und man sich wünscht das immer die richtige Funktion aufgerufen wird."

Die kommentare im folgenden sind als Sprechender Kompiler zu verstehen;)

Fall 1: cout << k2->getel();  //k2 ist vom Typ Koerper*, also rufe ich die Funktion getel() von Koerper auf.

Fall 2: cout << k2->getel();  //k2 ist vom Typ Koerper*, also rufe ich die Funktion getel() von Koerper auf, moment mal! 
//Da hat jemand virtual hingeschrieben, kann es sein, dass der inhalt auf den k2 zeigt doch nicht vom typ Koerper ist? 
//Ich schaue nach und stelle fest, der Inhalt von k2 ist in wahrheit eine Kugel, also rufe ich getel() von Kugel auf.

D.h. der Comiler "schaut"(der Compilter erstellt sich tatsächlich eine tabelle, weshalb viele virtuals calls Performanceeinbußen bringen) nach ob es wirklich die Basisklasse ist und nicht eine abgeleitete Klasse. Das kann er aber nur, wenn du mit Referenzen und Pointern arbeitest. Im Fall k1 = k3 wurde es einfach kopiert und ist daher nicht mehr nachvollziehbar, weil kein Verweis(Pointer) auf das original mehr existiert.

zu b)
bei k2->getel() muss er das virtual berücksichtigen, denn das Original könnte nicht vom typ k2 sein.
Bei k3.getel() ignoriert er das virtual, denn er hat bereits das Originalobjekt und dessen Typ.

Evtl. noch nützlich:

virtual int memberFunktion() = 0; //Das =0 macht die Funktion zu einer rein virtuellen Funktion

Diese rein virtuelle funktion MUSS von jeder Abgeleiteten Klasse überschrieben werden, sonst gibts einen Fehler.

In der Zeile k1 = k3 wird alles Kopiert, d.h. dein Abgeleitetes Objekt(Kugel) wird zur Basisklasse(Koerper).

Ist es nicht genau andersherum? (Oder: Es wird doch k1 etwas zugewiesen, warum verändert sich dann k3?)

Jede Kugel ist auch ein Körper, hat damit einen Anteil Körper intus. Bei der Zuweisung wird genau dieser Anteil kopiert! Deshalb ist jetzt aber k1 nicht gleich eine kugel (wie auch)

Also bekommt k1 hier Daten kopiert, die er sowieso schon besitzt ?

In der Zeile k1 = k3 wird alles Kopiert, d.h. dein Abgeleitetes Objekt(Kugel) wird zur Basisklasse(Koerper).

Ist es nicht genau andersherum? (Oder: Es wird doch k1 etwas zugewiesen, warum verändert sich dann k3?)

k3 ändert sich doch gar nicht, sondern k1! In deinem Beispiel ist das jetzt weniger wild, Kugel hat keine weiteren Data-Member. Angenommen es gäbe noch einen radius in Kugel.
Bei der Zuweisung k1 = k3 könnte der ja nicht in k1 kopiert werden - es fehlt schlicht der Speicher!

Jede Kugel ist auch ein Körper, hat damit einen Anteil Körper intus. Bei der Zuweisung wird genau dieser Anteil kopiert! Deshalb ist jetzt aber k1 nicht gleich eine kugel (wie auch)

Also bekommt k1 hier Daten kopiert, die er sowieso schon besitzt ?

Nein, k1 bekommt Daten kopiert, die in k3 liegen.

Machs dir nicht so kompliziert! Überleg dir was hier passiert, dann verstehst du das vllt. auch besser was hier hier erzählen:

Kugel k1;
Kugel k2;
k2 = k1;

l'abra d'or schrieb:

Nein, k1 bekommt Daten kopiert, die in k3 liegen.

JaykopX schrieb:

Dadurch hast du in k1 das getel() von Koerper.

Wenn die Daten von k3 in k1 kopiert wurden - warum bleibt das ursprüngliche getel() bestehen?

Wenn die Daten von k3 in k1 kopiert wurden - warum bleibt das ursprüngliche getel() bestehen?

Weil Membermethoden im Gegensatz zu Memberdaten nicht pro Objektinstanz gespeichert werden, sondern nur einmal im Speicher liegen. Der compiler sorgt dafür, dass ein Objekt immer die Methoden bekommt die die entsprechende Klasse implementiert - solange es nicht virtulle Funktionen sind!

Koerper k1;
k1.getel();   // k1 ist ein Koerper -> Koerper::getel()
Kugel k2;
k1 = k2;      // kopiere Koerper-Basisanteil von Kugel k2 in Koerper k1
k1.getel();   // k1 ist immer noch ein Koerper -> Koerper::getel()

Und k1 ist vom Typ Koerper, daher kann k1 auch nichts anderes aufrufen als funktionen von sich selber, es ist kein Pointer.