+ operator überladen

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...

ChrissiB

camper hat die Lösung doch schon gesagt.
Du musst auch den +=-Operator überladen.

finix

Shade Of Mine schrieb:

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

Hat das irgendwelche Vorteile gegenüber

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

?

Shade Of Mine

finix schrieb:

Hat das irgendwelche Vorteile gegenüber

Ich finds schoener
Ich mag Zuweisung im return nicht.

Aber das ist absolute geschmackssache und dein Code ist kein bisschen schlechter.

Jetzt passt der operator endlich vielen dank....

....

Betrag();
	Betrag(double y);

	Betrag& operator+=(const Betrag b2)
	{
	wert+=b2.wert;
	return *this;
	}

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

	Betrag::Betrag(double y){
		wert=y;
	}

aber wie kannich jetzt die beiden Strings vergleichen?
so dass die bezeichnungen der beiden zu addierenden beträgen
übereinstimmen? ich kenn nur strcpy. geschieht der vergleich
im überladenen Konstruktor+ ?

finix

[cpp]
Betrag& operator+=(const Betrag**&** b2) // <--- hier sollte ne ref hin
{
wert+=b2.wert;
return *this;
}
[/cpp]

schmitti schrieb:

aber wie kannich jetzt die beiden Strings vergleichen?

Mit den ganz normalen Vergleichsoperatoren, die sind beim std::string überladen.

schmitti schrieb:

ich kenn nur strcpy.

Hat aber nichts mit Vergleichen zu tun - wenn schon dann strcmp.

schmitti schrieb:

geschieht der vergleich
im überladenen Konstruktor+ ?

Wäre fast sinnvoll wenn du verschiedenen Währungen o.ä. hast, meinst du nicht?

mein String-Vergleich, der die Bezeichnungen überprüft und bei gleicher Bezeichnung dann die werte addiert sieht mal so aus:

const Betrag operator+(Betrag b1, const Betrag& b2)
	 {
		if (b1.bez==b2.bez)
		return b1+=b2;
		else
		{ 
			cout<<"fehler";
		}
	 }

Passt das so?

interpreter

schmitti schrieb:

mein String-Vergleich, der die Bezeichnungen überprüft und bei gleicher Bezeichnung dann die werte addiert sieht mal so aus:
const Betrag operator+(Betrag b1, const Betrag& b2)
	 {
		if (b1.bez==b2.bez)
		return b1+=b2;
		else
		{ 
			cout<<"fehler";
		}
	 }
Passt das so?

Nö, weil du im else-Zweig nichts zurückgibst.