Meine Frage ist jetzt: Warum darf man sowas nicht machen??

std::vector<float> & operator+(std::vector<float> & u , std::vector<float> & v ) {

	std::vector<float> * w = new std::vector<float>(u); // HIER
	if(u.size() == v.size()) {

	     for (unsigned int i = 0; i < u.size(); ++i) {
			(*w)[i] += v[i];   // HIER
			}
		return (*w);// HIER
		}

		cout << "vectoraddition FAILED!! different sizes" << endl;
		return (*w);// und HIER
	}

Der Gedanke dabei war , dass im Gegensatz zu einer lokalen Variablen das kopieren entfallen würde da ich eine Referenz zurück geben kann.
Gibt es ein andere Möglichkeit eine Referenz zurück zu geben wo ich nicht meinen ganzen Arbeitsspeicher zumülle oder ist einfach folgendes die richtige lösung:

std::vector<float>  operator+(std::vector<float>  u , std::vector<float>  v ) {

		std::vector<float>  w(u);
		if(u.size() == v.size()) {

			for (unsigned int i = 0; i < u.size(); ++i) {
				w[i] += v[i];
			}
			return w;
		}

		cout << "vectoraddition FAILED!! different sizes" << endl;
		return w;

	}

Wobei ich mich dann frage warum es keine Lösung mit Referenzen gibt..
besten Dank, simon

Wobei ich mich dann frage warum es keine Lösung mit Referenzen gibt..

Referenzen müssen immer auf ein bestehendes Objekt verweisen. Durchaus sinnvoll, wenn ein Operator eines der Objekte verändert, da kann man einfach eine Referenz zurückgeben.

Der operator+ erzeugt aber neue Daten, von daher gibt man da auch ein frisches Objekt zurück.

Alles klar, in diesem Fall wäre dann zb += der Kandidat für die Referenz, oder?

Genau!

Damit hatte ich auch angefangen,
das wäre dann ein Wrapper für einen vector<T> oder? d.h. ich müsste sehr viele methoden weiterleiten, oder nicht?

Irgendwie kann ich mir nicht vorstellen, dass ein Vektor im mathematischen Sinne sehr viele der Memberfunktionen von std::vector benötigt. Operator[] und vielleicht noch ein Konstruktor im C++11-Stil. Was willst du mehr?