Probleme beim Operator überladen

[solarwind]

Hallo!
Ich habe ein Problem mit dem Überladen von Operatoren. Ich habe eine Klasse Vektor und ich würde gerne mit denen rechnen. Aufgaben wie Vektor x + Vektor y und Vektor x*double a funktionieren schon aber bei Aufgaben wie Vektor x * double a + Vektor x versagt mein Code.
Was mache ich falsch? Vielen Dank im Voraus!

#include <iostream>
using namespace std;

class Vektor
{
private:
	/* Komponenten eines Vektors */
	double mx;
	double my;
	double mz;
public:
	/* Konstruktoren und Destruktoren */
	Vektor();
	Vektor(double, double, double);
	virtual ~Vektor();
	/* Referenzen */
	double &x;
	double &y;
	double &z;
	/* Überladungen */
	friend ostream& operator<<( ostream& os, const Vektor& objekt);
	friend Vektor operator+(Vektor &vek1, Vektor &vek2);
	friend Vektor operator*(Vektor &vek1, Vektor &vek2);	// * <- Vektorprodukt
	friend Vektor operator*(Vektor &vek1, double a);		// * <- Skalare Multiplikation
};

Vektor::Vektor(void): mx(), my(), mz(), x(mx), y(my), z(mz) {}
Vektor::Vektor(double t_x, double t_y, double t_z): x(mx), y(my), z(mz) { 
	mx=t_x; my=t_y; mz=t_z;}
Vektor::~Vektor(void){}

ostream& operator<<( ostream& os, const Vektor& objekt) {
	os << "Vektor: (" << objekt.x << "," << objekt.y << "," << objekt.z << ") \n";
	return os;
} 

Vektor operator+(Vektor &vek1, Vektor &vek2) {
	Vektor temp;
	temp.mx=vek1.mx+vek2.mx;
	temp.my=vek1.my+vek2.my;
	temp.mz=vek1.mz+vek2.mz;
	return temp;
}

Vektor operator*(Vektor &vek1, Vektor &vek2) {
	Vektor temp;
	temp.x = vek1.y*vek2.z - vek1.z*vek2.y;
	temp.y = vek1.z*vek2.x - vek1.x*vek2.z;
	temp.z = vek1.x*vek2.y - vek1.y*vek2.x;
	return temp;
}

Vektor operator*(Vektor &vek1, double a) {
	Vektor temp;
	temp.x = vek1.x*a;
	temp.y = vek1.y*a;
	temp.z = vek1.z*a;
	return temp;
}

int main(void) {
	Vektor x(1,2,3);
	cout << x;
	double a = 10;
	cout << x*a;
	cout << x*a + x;
	return 0;
}

[drakon]

*BULLSHIT*

Ansonsten. Was geht den nicht richtig?

[camper]

Ich vermisse Copy-ctor und den Zuweisungsoperator. Ersterer wird vom Compiler nicht in gewünschter Weise erzeugt werden, letzterer kann nicht implizit definiert werden. Nichtstatische Referenzen und Datenkonstanten sind im Allgemeinen recht unhandlich, meinem Eindruck nach sind sie sogar praktisch immer logisch falsch oder jedenfalls wie hier - überflüssig. Für so etwas gibt es Memberfunktionen, hier Referenzen einzusetzen, macht das Kopieren umständlich, verschwendet Speicher und ist vor allem nicht const-korrekt. Letzteres ist im Übrigen auch dein Problem: da rvalues nicht an nicht-const-Referenzen gebunden werden können, kann das Ergebnis der Multiplikation nicht Argument deines Additionsoperators sein. Der enstrpechende Parameter muss entweder eine Referenz auf const oder ein Objekt sein.

[camper]

drakon schrieb:

Es ist schon mal schlecht ganze Vektoren zurückzugeben. Am besten du gibst einfach Referenzen zurück:

friend Vektor& operator*(Vektor &vek1, Vektor &vek2);

Grober Unfug. Das vergessen wir am Besten gleich wieder.

[LordJaxom]

Das Problem dürfte sein, dass ein Ausdruck Vektor * double einen temporären Vektor zurückgibt. Irgendwas war da, dass man in best. Situationen temporäre Objekte nicht an nicht-konstante Referenzen binden kann. Damit fällt der Aufruf (Ergebnis von Vektor * double) + Vektor flach.

Mach die Parameter an die Operatoren mal konstant.

(EDIT: Für die Definition von "irgendwas" siehe campers erster Post :D)

@drakon: Das ist bei der Rückgabe temporärer Objekte keine gute Idee

[drakon]

camper schrieb:

Ich vermisse Copy-ctor und den Zuweisungsoperator. Ersterer wird vom Compiler nicht in gewünschter Weise erzeugt werden, letzterer kann nicht implizit definiert werden. Nichtstatische Referenzen und Datenkonstanten sind im Allgemeinen recht unhandlich, meinem Eindruck nach sind sie sogar praktisch immer logisch falsch oder jedenfalls wie hier - überflüssig. Für so etwas gibt es Memberfunktionen, hier Referenzen einzusetzen, macht das Kopieren umständlich, verschwendet Speicher und ist vor allem nicht const-korrekt. Letzteres ist im Übrigen auch dein Problem: da rvalues nicht an nicht-const-Referenzen gebunden werden können, kann das Ergebnis der Multiplikation nicht Argument deines Additionsoperators sein. Der enstrpechende Parameter muss entweder eine Referenz auf const oder ein Objekt sein.

Mist. Hatte falsch im Kopf. Das war ja die Übergabe, die ich gemeint habe. :S

Hast natürlich Recht.

@drakon: Das ist bei der Rückgabe temporärer Objekte keine gute Idee

Jah.. Habs kapiert. - Habs in meinem Vektor ja auch richtig gemacht. Als ich das geschrieben hatte ich irgendwie Zweifel, dass das stimmt, habe dann aber gedacht, dass ich das auch so gemacht habe (was ich aber eben nicht gemacht habe..). Naja..

[solarwind]

Danke der Tip von LordJaxom hat geholfen