Überladung von Operatoren, zwei Klassen

Hallo,

Habe eine kleine Frage zum Überladen von Operatoren wenn man zwei Objekte verschiedener Klassen z.B. addiert.

Nehmen wir an wir haben class Eins und class Zwei (jede nur eine Eigenschaft sagen wir 'Wert') mit den Instanzen:

Eins A(30), B(40);
Zwei C(50), D(60);

Brauche ich jetzt 4 Überladungsfunktionen?
bei: A + B;
C + D;
A + D;
D + A;

Oder gibt's da irgendeinen Trick?

Danke schonmal im Voraus!

Jester

Wenn sich eines der Objekte in ein anderes konvertieren läßt kommst Du auch mit weniger aus.

Dazu genügt zum Beispiel ein nicht als explicit deklarierter Konstruktor:

class Zwei
{
Zwei(Einst const& obj);
};

Allerdings mußt Du Dir gut überlegen, ob Du

a) diese implizite Konvertierung wirklich haben willst (vielleicht schlägt die sonst an unerwarteten Stellen zu

b) Du den Zeit- und Speicheraufwand für die anfallenden temporären Objekte zahlen willst.

roan312

Soweit ich weiß brauchst du nur 2.
Eine für Eins + Zwei und eine für andersrum. #
(Ich habe mich vom Operatorenüberladen immer etwas distanziert, könnte auch falsch sein...)

MfG RoaN;

PS.: Dieser Smilie hier: sieht doch absolut angeberisch aus, oder?

//EDIT: Mist, zu spät!

Also, ich habe zwar gerade mit überladen von Operatoren angefangen, aber ich versuchs mal trotzdem....

Ich würde mal sagen du brauchst nur 2 Überladungsfunktionen.

Denn:

Du hast 3 mal D drin und das sind alles additionen und da ändert sich ja bekanntlich das ergebnis nicht wenn die summanden vertauscht sind

Du brauchst also eine Überladungsfunktion für D und A

A+B
D+A
D+C

------------------
Du hast ja einmal D+A und A+D ---> das ist ja das selbe also brauchst du nur eins

(Hoffe das ich nichts falsches gesagt habe)

hmmm...

aber dann könnte ich ja nicht 2 Objekte der GLEICHEN klasse addieren oder?

Need_Help! schrieb:

hmmm...

aber dann könnte ich ja nicht 2 Objekte der GLEICHEN klasse addieren oder?

Wieso nicht???? Ich denke mal schon !!!!

Hier mal der quellcode:

class Geld
{
  friend class Kies;                            // Einbinden der Friend-Klasse Kies
  float moneten;
 public:
  Geld();                                       // Standardkonstruktor, reserviert Speicherplatz
  Geld(float);                                  // Konstruktor, übergeben der Moneten
  Geld& operator+(Geld& kopie)                  // Überladen des +OP's für die Klasse Geld
   {
    moneten = moneten + kopie.moneten;
    return *this;
   }
  friend ostream& operator<<(ostream&, const Geld&);     // Überladen des <<Op's mit einer friend-Funktion
  friend istream& operator>>(istream&, Geld&);           // Überladen des >>Op's mit einer friend-Funktion
};

class Kies
{
  friend class Geld;
  float moneten;
 public:
  Kies(){}
  Kies(float f){moneten = f;}
  Kies& operator+(Kies& kopie2)
   {
    moneten = moneten + kopie2.moneten;
    return *this;
   }
  Kies& operator+(Geld& kopie)
   {
    moneten = moneten + kopie.moneten;
    return *this;
   }
  friend ostream& operator<<(ostream&, const Kies&);
  friend istream& operator>>(istream&, Kies&);
};

Jetzt kommt ein Fehler wenn ich z.B. A(instanz von Geld) + B(Instanz von Kies) mache. Nur andersrum (B + A) geht es.

bitte antwort.. habe morgen referat

finix

Eins vorab: du hast (zumindest logisch gesehen) jeweils operator+= überladen.

Wenn Jesters Lösung bzw der Hinweis auf Konvertierbarkeit dich nicht zufrieden stellt brauchst du tatsächlich 4 Funktionen. Praktischerweise solltest du dann vielleicht wirklich die += ops überladen und + mithilfe dieser implementieren.

Bleibt nur noch die Frage was bei Geld + Kies rauskommen soll, Geld oder Kies oder Zaster oder Kohle oder Schotter oder, oder, oder..

Ok nehmen wir mal an ich möchte 4 Funktionen benutzen,
wo würde ich die im oben angegebenen QC reinschreiben?
könnte es jmd mal abändern, bekomme immer fehler wenn ich die 4te benutze..

also:

Geld + Geld geht
Kies + Kies geht
Kies + Geld geht
Geld + Kies geht nicht

finix

Du hast meinen Post gelesen, ja? Wunderbar.

// freie Funktionen

Kies operator+( const Kies& lhs, const Geld& rhs )
{ return Kies(lhs) += rhs; }

Kies operator+( const Kies& lhs, const Kies& rhs )
{ return Kies(lhs) += rhs; }

Geld operator+( const Geld& lhs, const Kies& rhs )
{ return Geld(lhs) += lhs; }

Geld operator+( const Geld& lhs, const Geld& rhs )
{ return Geld(lhs) += lhs; }

// NB: Rueckgabetypen...

Danke,

Jetzt hab ich aber noch eine Frage:

- Wenn ich externe Funktionen dafür benutze muss ich die Elemente ja public
machen oder?

- Kann ich das irgendwie abfangen, das:
A(5), B(10)
C = A + B; // 15

D = A; // auch 15, will aber das es wieder 5 ist!

finix

Need_Help! schrieb:

Danke,

Wofür, du scheinst mit meinen Antworten doch ohnehin nichts anzufangen.

Need_Help! schrieb:

Jetzt hab ich aber noch eine Frage:

Ja, wirklich?

Need_Help! schrieb:

- Wenn ich externe Funktionen dafür benutze muss ich die Elemente ja public
machen oder?

Nein.

Need_Help! schrieb:

- Kann ich das irgendwie abfangen, das:
A(5), B(10)
C = A + B; // 15

D = A; // auch 15, will aber das es wieder 5 ist!

Ja.
(Hinweis: habe ich schon gepostet.)

jajaja += sorry bin weng verpeilt

danke danke.