+ operator überladen

interpreter

spjoe schrieb:

Betrag& operator+(Betrag& b1, Betrag& b2)

Eine Referenz auf ne lokale Variable? Autsch

spjoe

habs einfach nur runter gschrieben und eine referenz reicht auch siehe copy konstruktor oben !!!

terraner

in der klasse definiert, übernimmt der operator+ nur ein argument, wobei der erste summand *this ist. um das zu umgehen, definierst du den op+ außerhalb, eventuell auch als friend, um direkten zugriff auch die member zu haben.

class Foo
{ 
 public:
    Foo(int i = 0) : i_(i) {}
    friend const Foo operator+ (const Foo& left, const Foo& right);
    int getValue() const {return i_; }
 private:
    int i_;
};
/* // ohne friend
const Foo operator+ (const Foo& left, const Foo& right)
{
 return left.getValue() + right.getValue();
}
*/
const Foo operator+ (const Foo& left, const Foo& right)
{
 return left.i_ + right.i_;
}

mfg

interpreter

spjoe schrieb:

habs einfach nur runter gschrieben und eine referenz reicht auch siehe copy konstruktor oben !!!

Nicht wirklich.
Übrigens: Der übermäßige Einsatz von Ausrufezeichen wirkt aggressiv und unseriös

Michael E.

spjoe schrieb:

habs einfach nur runter gschrieben und eine referenz reicht auch siehe copy konstruktor oben !!!

Redest du mit interpreter? Wenn ja, dann "autsch".

spjoe

sry interprter wollt enich aufdringlich sein will nur helfen hast recht mit den refernce. hab im moment ziemlich viel zu tun. also entschuldige bitte meine fehler

interpreter

spjoe schrieb:

sry interprter wollt enich aufdringlich sein will nur helfen hast recht mit den refernce. hab im moment ziemlich viel zu tun. also entschuldige bitte meine fehler

Brauchst dich doch nicht entschuldigen - jeder macht hier Fehler. Das mit den Ausrufezeichen sollte übrigens kein Angriff sein, nur ein nett gemeinter Ratschlag

compiler meckert zwar nicht, aber kann man das so machen:

public:
	double wert;
	std::string bez;

public:

	Betrag();
	Betrag(double y);
	Betrag (const Betrag& abc) {
		wert = abc.wert;
		bez =abc.bez;
	}

};		
	Betrag operator+(Betrag& b1, Betrag& b2)
	 {
		double wert = b1.wert + b2.wert; 
	 }

spjoe

du musst was zurück geben im operator

a = b + c

compiler rechnet zuerst b +c zusammen speicher das ergebnis in tmp variable und gibt es dann a weiter

Michael E.

Ja, allerdings hat das nicht den Effekt, den du haben willst. Z.B. hast du den Konstruktor mit dem double-Parameter nicht definiert.

Walli

Michael E. schrieb:

float benutzt auch fast keiner, sondern double.

Lass das nicht die Gamer hören .

Michael E. schrieb:

Ja, allerdings hat das nicht den Effekt, den du haben willst. Z.B. hast du den Konstruktor mit dem double-Parameter nicht definiert.

welchen effekt hat es denn dann? Dieser Konstruktor soll einfach nur, y zB auf 10,5 euro setzen.

was soll ich den zurückgeben?

Michael E.

Dann musst du den wert auch setzen.

Betrag::Betrag(double d)    // schlechter als Variante 2
{
    wert = d;
}

// das hier wirst du wahrscheinlich nicht verstehen, ist aber besser als Variante 1
Betrag::Betrag(double d) : wert(d);

BTW: Konstruktoren geben nie was zurück!

passt dann jetzt der überleadene operator+ ?
die überprüfung ob die beiden "bez" gleich sind, macht man am besten mit strcpy?

finix

Betrag::Betrag(double d) : wert(d) { } // <----

Zumindest wird Variante 1 ohne Fehler kompiliert

Michael E.

finix schrieb:

Betrag::Betrag(double d) : wert(d) { } // <----
Zumindest wird Variante 1 ohne Fehler kompiliert

Ach du Scheiße, nee

Ab jetzt wird erst alles durch en Compiler gejagt und getestet

Shade Of Mine

3 seiten und nicht einmal die richtige op+ implementierung

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

so baue ich idr meinen op+

schoen kurz, nicht?

Michael E.

Shade: Ich wusste, ich hab was vergessen (nämlich den op+ anzufassen).

camper

class Betrag {
public:
    double wert;
    std::string bez;

public:

    Betrag();
    Betrag(double y) : wert( y ) { }
/*    Betrag (const Betrag& abc) {
		wert = abc.wert;
		bez =abc.bez;
	}*/

};		
const Betrag operator+(const Betrag& b1, const Betrag& b2) {
    return Betrag( b1.wert + b2.wert );
}

+ sollte eine const Betrag zurückliefern, ansonsten wäre so etwas wie

( a + b ) = c;

möglich, was sinnlos und unintuitiv wäre. Das wiederum impliziert, dass + argumente als reference-to-const nehmen muss, sonst könnte man ja nicht

d = a + b + c;

schreiben. Einen Copy-C'tor wiederum sollte man nicht schreiben, wenn der default-copy-c'tor dasselbe tut. erstens ist es überflüssig, zweitens verhindert es häufig sinnvolle optimierungen durch den compiler.
z.b. wird bei

c = a + b;

wenn kein = operator und copy-c'tor definiert sind, wird jeder compiler, der etwas taugt, das temporary, was im operator + entsteht, gleich im speicher von c konstruieren und so den aufruf von copy-c'tor bzw. operator = überflüssig machen.

besser implementiert man + nat., wie shade schon gezeigt hat, mittels +=

class Betrag {
public:
    double wert;
    std::string bez;

public:

    Betrag();
    Betrag(double y) : wert( y ) { }
/*    Betrag (const Betrag& abc) {
		wert = abc.wert;
		bez =abc.bez;
	}*/
    Betrag& operator+=( const Betrag& rhs ) {
        wert += rhs.wert;
        return *this;
    }
};		
const Betrag operator+(Betrag lhs, const Betrag& rhs) {
    return lhs += rhs;
}

ganz nebenbei kann man jetzt wert ohne probleme private machen, ohne gleichzeitig + als friend deklarieren zu müssen.

Shade Of Mine schrieb:

3 seiten und nicht einmal die richtige op+ implementierung
T operator+(T a, T const& b)
{
  a+=b;
  return a;
}
so baue ich idr meinen op+

schoen kurz, nicht?

ja, sowas leuchtet mir irgendwie ein...
nur leider funktioniert das bei mir nicht...

Betrag operator+(Betrag b1, Betrag const& b2)
	 {
		b1+=b2;
		return b1;
	 }

no match for 'operator+=' in 'b1 += b2' -> kommt als Fehlermeldung...