OOP für duµs

Heuschrecke

Hallo,
bin gerade auf Seite 152 im Buch "OOP für Dummies" und dort steht:
"Beachten Sie unbedingt, dass die Operatoren keine unerwünschten Seiteneffekte verursachen. Wenn der Operator+ in OpDemo1 zum Beispiel so realisiert würde:

const OpDemo1 operator+(const OpDemo1& right)
{
   return m_Value + right.getValue();
}

wird bei der Addition der linke Operator ebenfalls mitgeändert (..)

OpDemo1 a(5);
OpDemo2 b(10);
OpDemo3 c = a + b;

würde auch in a die 15 stehen!"

Hab ich jetzt ausprobiert und stimmt gar nicht, bei a steht weiter die 5.
Kapier ich da grad was nicht?

#include <iostream>

using namespace std;

class OpDemo1
{
public:
   OpDemo1(int value)
      : m_Value(value) {}
   int getValue() const {return m_Value;}
   const OpDemo1 operator+(const OpDemo1& right)
   {
      return m_Value + right.getValue();
   }
private:
   int m_Value;
};

int main()
{
   OpDemo1 a(5);
   OpDemo1 b(10);
   OpDemo1 c = a + b;

   cout << "OpDemo1 - a-Wert:" << a.getValue() << endl;
   cout << "OpDemo1 - c-Wert:" << c.getValue() << endl;

   return 0;
}

mit Ausgabe:
OpDemo1 - a-Wert:5
OpDemo1 - c-Wert:15

Shade Of Mine

du hast einen Fehler im Buch entdeckt.

gemeint ist vermutlich

const OpDemo1& operator+(const OpDemo1& right)
{
   m_Value+=right.getValue();
   return *this;
}

aber beachte, dass bei deinem code folgendes nicht geht:

int main()
{
   const OpDemo1 a(5);
   OpDemo1 b(10);
   OpDemo1 c = a + b;

   cout << "OpDemo1 - a-Wert:" << a.getValue() << endl;
   cout << "OpDemo1 - c-Wert:" << c.getValue() << endl;

   return 0;
}

Walli

Sicher, dass das genau so da steht?

Shade Of Mine

MaSTaH schrieb:

Sicher, dass das genau so da steht?

jep, leider.

Heuschrecke

*stolzsei*

terraner

Shade Of Mine schrieb:

const OpDemo1& operator+(const OpDemo1& right)
{
   m_Value+=right.getValue();
   return *this;
}

wieso eine referenz auf das bestehende objekt übernehmen? und wieso eine referenz auf rhs/right?

String String::operator+ (const String rhs) 
{
    String tmp;
    tmp = String(*this);
    tmp += rhs;

 return tmp;
}

schließlich ist es ja normalerweise das "ziel" mit einem '+', zwei werte zu addieren und einem dritten objekt zu speichern.

ps: "-W -Wall -ansi -pedantic", Dev-Cpp 49.87

[edit]das ist meine string class[/edit]

mfg

rüdiger

@terraner

man benutzt const-Referenzen idr. zum übergeben von nicht-Builtin Typen, weil man sich den Aufruf des copy-ctors spart, was deutlich schneller sein sollte

terraner

kingruedi schrieb:

@terraner

man benutzt const-Referenzen idr. zum übergeben von nicht-Builtin Typen, weil man sich den Aufruf des copy-ctors spart, was deutlich schneller sein sollte

O_o, stimmt ja, dann wird der CpyCtor gar nicht aufgerufen, wenn ich eine referenz übergebe. ach was, ihr habt bloß noch niemeine extrem schnellen cpyctors gesehen. dann würdet ihr anders urteilen
Danke für den Hinweis!

mfg

String tmp;
    tmp = String(*this);

und sowas auch direkt machen

String tmp(*this);

davie

wenn wir schon dabei sind, eigentlich ist es ja

String operator + (const String &a, const String &b) {
   String tmp(a);
   tmp += b;
   return tmp;
}

terraner

davie schrieb:

wenn wir schon dabei sind, eigentlich ist es ja
String operator + (const String &a, const String &b) {
   String tmp(a);
   tmp += b;
   return tmp;
}

das funzt bei mir nicht. das habe ich auch so in meinem tut gelesen (c++ in 21 tagen), aber dev-cpp meckert dann rum, dass "operator+ must take either zero or one argument". deshalb mache ich das so.

mfg

davie

->definiere operator+ nicht als memberfunktion.

class String {
/* ... */
};

String operator + (/* ...
*/

terraner

davie schrieb:

->definiere operator+ nicht als memberfunktion.
class String {
/* ... */
};

String operator + (/* ...
*/

noch etwas gelernt. danke.
ich habe es inzwischen aber so gemacht:

String String::operator+ (const String &rhs) 
{
    String tmp(this->m_pChar);
    tmp += rhs;

 return tmp;
}

ist das genauso schnell?

mfg

davie

wenn das

String tmp(this->m_pChar);

nicht schneller als ein copy ctor ist.

allerdings liegen bei + als member funktion ganz andere probleme.
stell dir vor

String foo("blub");

String bar = foo + "ok";
String nope = "oje" + foo; //crash

weil der compiler versucht, "oje" + foo; aufzulösen in

"oje".operator+ (foo); //das klappt nicht
//andersrum
foo.operator+ ("oje"); //klappt allerdings schon, wenn es eine konvertierung von const char* nach String gibt.

der zweiparametrige operator+ kann jedoch auch sein erstes argument notfalls umwandeln.