Brauche gute Gründe!

Hi,

ich bräuchte paar (so 2-4) sehr gute Gründe, wieso man z.B. operator + über den operator += implementieren sollte und wieso operator + außerhalb der klasse sein sollte.

volkard

********* schrieb:

Hi,

ich bräuchte paar (so 2-4) sehr gute Gründe, wieso man z.B. operator + über den operator += implementieren sollte und wieso operator + außerhalb der klasse sein sollte.

op+ außerhalb con klassen, damit 5+Rational(5) genausogut geht, wie Rational(5)+5.
mit dem op+ innerhalb müßte das linke argument immer genau vom typ Rational sein und könnte nicht praktischerweise von nem typumwandlungskonstruktor (einem konstruktor, der genau ein argument nimmt und kein kopierkonstruktoe ist) erzeugt werden. siehe "effektiv c++ programmieren" für mehr text.

den op+ und den op+= macht man natürlich irgendwie zusammen, daß einer den anderen aufruft. aber warum den op+ durch den op+= und nicht andersrum?
liegt unter anderem an der performace.
der op+= gibt nur *this als referenz zurück. der op+ gibt aber ne teure (wenn wire mal an string denken) kopie zurück.
also haben wir nen schnellern op+= und nen langsameren op+. würden wir dummerweise den op+= durch den op+ implementieren, wären beide lahm. das muß ja nicht sein.

mehr gründe fallen mir gerade nicht ein, aber ich denke mal, nicht die anzahl der gründe (2-4) ist entscheidend, sondern daß man hinreichende gründe hat.

edit: ach, was soll der geiz?

man implementiert den einen durch den anderen natürlich, um weniger code da stehen zu haben, vor allem, weil weniger code auch weniger fehler hat.

der op+= ist irgendwie der "natürlichere" op. man nimmt ihn lieber und häufiger als den op+. insofern gefällt es einem, den zuerst zu machen und als den zu haben, der die information trägt.

der op+= darf eh in de klasse. da ist er gut aufgehoben. lines argument vom typ Rational sein, sonst wäre der aufruf ja unfug.

wenn ich es mir dann leiste, den op+ globale zu machen, braucht er nichtmal friend zu sein! bring wieder sicherheit und entkoppelt. der op+ braucht ja nur den op+= zu benutzen.

mal kurz die andere lösung angucken:

Rational& Rational::operator+=(Rational& rhs){
   *this=*this+rhs;
   return *this;
}

das ist ja ne lachnummer! zuerst ein aufruf des op+, erzeugung eines temporären objekts bei der rückgabe und aufruf des zuweisungsoperators. nee, das ist einfach zu lahm. kann man so nicht machen, wenn es doch so ne einfache alternative gibt.

wenn du die forensuche bemuehst, wuerdest du sicher mehr als genug gruende finden. aber weil ich nicht gemein sein will, erfuelle ich mal deine minimal anforderungen und nenne dir zwei gruende:

operator+ mit operator+= implementieren:
du bist faul . das ist auch schon alles. es macht halt keinen sinn den fast gleichen code zwei mal zu schreiben. ausserdem falls du einen fehler im code entdeckst musst du nur den operator+= anpassen. auf die gefahr hin, dass ich mich wiederhole: sei faul!
operator+ global:
ganz einfach: wenn der operator+ member ist, dann muesste der linke operand immer eine instanz der klasse sein. einfaches beispiel:

class Int  { /*...*/ }; // klasse, die ganzzahlen repraesentiert

Int I;
int i;

  // wenn der operator+ member ist

I + i;  // schoen
i + I;  // nicht schoen

  // der operator+ ist stattdessen global

I + i;  // schoen
i + I;  // schoen

was auch immer

Erhard Henkes

zur Ergänzung:
http://www.gotw.ca/gotw/004.htm (3.Style)