Überladung von Operatoren, zwei Klassen

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.