K
@Th
das haut nicht hin. der operator ist jetzt immer noch nicht polymorph. ich würde es so machen:
class AllgGeraet
{
public:
virtual void Inc() = 0;
virtual void Dec() = 0;
AllgGerät& operator ++ () { this->Inc(); return *this; }
AllgGerät& operator -- () { this->Dec(); return *this; }
};
class Heizung : public AllgGeraete
{
int x; // irgend ein Wert
public:
virtual void Inc() { ++x; }
virtual void Dec() { --x; }
Heizung& operator ++ () { this->Inc(); return *this; }
Heizung& operator -- () { this->Dec(); return *this; }
}
der trick ist, die operatoren nur als "abkürzung" für den aufruf der eigentlichen polymorphen element-funktionen zu benutzen. der "abkürzungs-operator" selbst ist zwar nicht polymorph, aber der vom operator durchgeführte aufruf der element-funktion schon.
weil sie so kurz sind, definiert man solche "abkürzungs-operatoren" am besten inline.
das problem, wenn du einen solchen operator in der klasse AllgGeraet definierst ist allerdings, daß er dann immer ein ergebnis vom typ AllgGeraet& zurückgibt. wenn du also ++heizung aufrufst, dann ist der wert dieses ausdrucks nicht vom typ Heizung& sondern vom typ AllgGeraet&! dafür hat der in der basisklasse definierte operator den vorzug, daß er von abgeleiteten klassen geerbt wird. du brauchst ihn dann nur einmal zu schreiben.
wenn du den operator in der klasse heizung definierst, dann kannst du ihn so schreiben, daß er auch einen wert vom typ Heizung& zurückgibt. du mußt das dann aber in allen von AllgGeraet abgeleiteten klassen machen.
du kannst aber auch, wie im obigen quelltext, beides zusammen machen. dann wird der operator bei objekten, in deren klasse er definiert ist, den richtigen typ zurückgeben. und bei objekten, deren klasse ihn nicht definiert, wird default-mäßig der operator der basisklasse aufgerufen.
