Ich habe mal eine kuze Frage bezüglich std::swap. Kann ich damit auch problemlos Objekte und Container tauschen (z.B. std::string oder std::vector)?
quasi so:

myClass &myClass::operator=(myClass const &other)
{
	myClass tmp(other);
	std::swap(myStdVector, tmp.myStdVector);
	std::swap(myStdString, tmp.myStdString);

	// ist das hier quatsch?:
	myUniquePtr.reset(tmp.myUniquePtr.release());

    return *this;
}

Benötige ich irgendwie std::move dafür oder ist es unproblematisch std::swap zu verwenden? Wie sieht es bei einem unique_ptr aus? Mein Bauchgefühl sagt mir, dass meine oben gezeigte Lösung nicht so gut ist. ...ich glaube hier müsste ich wohl std::move verwenden, oder?

viele Grüße,
SBond

Liegt eine Zuweisung vor A=B, so muss der Inhalt von B nach A kopiert werden. D.h. der Inhalt von B liegt am Ende zweimal vor. Einmal in B und einmal in A. Also ist hier ein std::move nicht angebracht.

Falsch ist lediglich die Zeile 8 (Ist das hier quatsch? -> Ja). Das geht genau dann schief, wenn &other==this ist. Ich unterstelle mal, dass es sich bei myUniquePtr um einen std::unique_ptr<> handelt.
Dann wäre ein std::swap( myUniquePtr, tmp.myUniquePtr ) genau richtig.

Empfehlung: packe das swap von myClass in eine eigene Methode. Das Assign sollte dann so aussehen:

myClass &myClass::operator=(myClass const &other)
{
    myClass tmp(other);
    tmp.swap( *this );
    return *this;
}

Gruß
Werner

Werner Salomon schrieb:

Empfehlung: packe das swap von myClass in eine eigene Methode.

Das habe ich schon einige male in Foren gesehen. Bietet es bestimmte Vorteile? So aus Stand heraus würde ich sagen, wenn man noch eine Move-Operation zur Verfügung stellen will. Aber derartiges habe ich zumindest noch nicht gesehen.

... Das Assign sollte dann so aussehen:

myClass &myClass::operator=(myClass const &other)
{
    myClass tmp(other);
    tmp.swap( *this );
    return *this;
}

Da wird eine Kopie angelegt. Dann kann man auch gleich per Wert übergeben, d.h.

myClass &myClass::operator=(myClass other)
{
    swap(other);
    return *this;
}

Der zusätzliche Vorteil dieser kürzeren Lösung ist, dass der Compiler den Kopierkonstruktoraufruf bei der Parameterübergabe wegoptimieren kann, wenn other ein temporäres Objekt ist.

Der zusätzliche Vorteil dieser kürzeren Lösung ist, dass der Compiler den Kopierkonstruktoraufruf bei der Parameterübergabe wegoptimieren kann, wenn other ein temporäres Objekt ist.

In welchen Fällen ist diese Variante zu bevorzugen gegenüber der Variante, einen move assignment operator zu implementieren?