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

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.

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.

Danke -.-'