+ operator überladen

spjoe

schmitti kannst uns mal die Dekleration von deine klasse geben! oda zumindest den teil mit den operator
mfg

so sieht das ganze ding bis jetzt aus:

class Betrag 

{
public:
	float wert;
	char* bez;
public:

	Betrag (const Betrag& abc) {
		wert = abc.wert;
		strcpy(bez, abc.bez);
	}

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

}

spjoe

#include <iostream>

class Betrag

{
private:
    float wert;
	std::string bez;
public:

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

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

nur brauchst da noch nen konstruktor der float akzeptiert !!
durch friends kannst auch auf privat sachen zugreifen !!

mfg

Michael E.

Wir sind hier im C++-Forum, also benutz besser std::string als char *. float benutzt auch fast keiner, sondern double. Da ich davon ausgehe, dass strcpy() nix mit Speicherallozieren zu tun hat (ist halt C), hast du keinen Speicher für *bez alloziert. Den operator+ würd ich immer noch aus irgendeinem Grund zum friend machen. Dir fehlt ein weiterer Konstruktor (z.B. ohne Parameter), da man so nicht das erste Objekt erstellen kann.

Michael E.

spjoe: Öhm, dir fehlt #include <string>, brauchst aber kein #include <iostream>. Hab ich auch ne Zeit lang automatisch gesetzt

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