#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;
}

Ansonsten. Was geht den nicht richtig?

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.

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

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