Operatorüberladung mit Polymorphie realisieren

Guntpat

Hallo zusammen! Ich programmiere gerade an einer Aufgabe und weiß nicht so recht, wie ich sie zu realisieren habe. Es geht darum, eine Fernbedienung zu programmieren, mit der man bestimmte Geräte (Heizung, Radio, Kaffeemaschine) bedient und deren Leistung erhöht bzw. erniedrigt (z.B. Temperatur bei Heizung und Lautstärke bei Radio). Nun soll dies mit Polymorphie realisiert werden. Es gibt eine Oberklasse AllgemeinesGeraet, von welchem alle Geräte (Heizung etc.) abgeleitet sind. Über ein Array von Gerätezeigern soll nun auf die Geräte zugegriffen werden - so soll z.B. über den überladenen operator++() die Lautstärke des Radios um 1 erhöht werden. Meine Frage ist nun, wie realisiere ich dieses inkrementieren mit Polymorphie? Ich kann ja schlecht den operator mit virtual definieren?

Th

Stimmt virtuelle Operatoren gibt es nicht, daher kannst du eine andere virtuelle Funktion definieren, so daß alle abgeleiteten Klassen jeweils ihren ++ Operator aufrufen, also

class AllgGeraete
{
public:
   virtual void Inc() = 0;
   virtual void Dec() = 0;
};

class Heizung : public AllgGeraete
{
public:
    virtual void Inc() { this->operator ++(); }
    virtual void Dec() { this->operator --(); }

    const Heizung& operator ++ () { ++x; return *this; }
    const Heizung& operator -- () { --x; return *this; }

private:
    int x; // irgend ein Wert
}

Konfusius

@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.