std::swap + reference

unskilled

Wie der Titel schon sagt, habe ich ein Problem mit std::swap auf Referenzen angewandt - glaube ich zumindest ^^

Folgendes kleines Beispiel:

template <typename Tfrom, typename Tto, typename Tcapacity_transport, typename Tmoney>
	class TTransportUnit
	{
	private:
		Tfrom  &start;
		Tto    &destination;
		Tcapacity_transport   capacity;
		Tmoney  trip_cost;
	public:
		TTransportUnit (Tfrom &_start, Tto &_destination, Tcapacity_transport _capacity)
			: start(_start), destination(_destination), capacity(_capacity), trip_cost(transport_costs_per_trip)
			{}

		TTransportUnit& operator = (const TTransportUnit &rhs)
		{	//the compiler (MSVC 08) dont want to generate this operator - so we had to write it
			TTransportUnit tmp(rhs);
			swap(tmp);
			return *this;
		}

		void swap (TTransportUnit &rhs) throw()
		{
			std::swap (start, rhs.start);
			std::swap (destination, rhs.destination);
			std::swap (capacity, rhs.capacity);
			std::swap (trip_cost, rhs.trip_cost);
		}
	};

namespace std
{	//specialising std::swap
	template <typename T1, typename T2, typename T3, typename T4>
	void swap (my::TTransportUnit <T1, T2, T3, T4> &lhs, my::TTransportUnit <T1, T2, T3, T4> &rhs) throw()
	{
		lhs.swap (rhs);
	}
}

int main()
{
	typedef typename my::TTransportUnit <THub, TSpoke, Tcapacity, Tmoney> TTransportUnit;
	typedef typename std::vector < std::pair <Tcapacity, TTransportUnit> > TTransportUnitContainer;

         std::vector <TSpoke> spokes;
//füllen
		TTransportUnitContainer transportunits;
		Tcapacity key = /*iwas mit kapazitäten rumrechnen*/;
		transportunits.push_back (std::make_pair (key, transportunit));
//füllen
		std::swap (transportunits[0], transportunits[5]);
}

und zwar wird manchmal (nicht immer) mein vector of TSpoke verändert (die zugehörigen Objekte werden dort auch getauscht)...
Ich rätsel jetzt schon seit Ewigkeiten, warum es nicht geht und bin iwie zu blöd, das rauszufinden... Es ist aber definitiv im swap-Aufruf verändert.
Falls es wichtig wäre:
Compiler: MSVC 08
OS: Vista 64bit

Wär toll, ne Antwort von euch zu hören ^^

bb : >

LordJaxom

Wär toll, das Problem zu verstehen ^^

Im Ernst, worum geht es Dir? Darum, dass die Referenzen (also die Verweisziele) untereinander getauscht werden? Wenn ja, vergiß es, ein Swap zweier Referenzen tauscht immer deren Inhalte. Das Referenzziel kann nur bei der Initialisierung festgelegt werden.

hustbaer

Vermutlich solltest du die Referenzen durch Zeiger ersetzen. Zeiger kannst du dann tauschen wie du magst. Und der Compiler wird sich dann vermutlich auch nichtmehr weigern einen copy-ctor zu erstellen. Tjo...

Nexus

Der Zuweisungsoperator kann nur automatisch generiert werden, wenn keine konstanten oder nichtkopierbaren Objekte zugewiesen werden müssen. Referenzen sind zwar keine Objekte, aber konstant und müssen somit bei der Definition initialisiert werden.

Also hast du mit dem eigenen Zuweisungsoperator nicht erreicht, was gewollt wäre. Es hat schon einen Grund, warum der Compiler hier reklamiert...

Wie gesagt wären Zeiger hier wohl besser geeignet.

unskilled

Ja - nach dem Schlafen ists mir dann auch aufgefallen, dass es eigtl total logisch ist x)
Werde wohl Zeiger nehmen, weils so was wie nen reference-swap ja vermutlich nicht gibt ^^

Danke -.-'