Weil ich gerade über diesen Thread gestolpert bin: Was genau ist denn eigentlich das Copy&Swap Idiom?

Foo& operator=(const Foo& f){
  Foo tmp(f);//klappt oder klappt nicht, ka, vielleicht kein speicher da?
//exception flieg oder fliegt nicht, alles ok. 
  swap(*this,tmp);//klappt sicher!!!
}

im Gegenśatz zum

Foo& operator=(const Foo& f){
  ort=f.ort;//klappt mal
  name=f.name;//klappt mal nicht, oh weh!!!
//exception fliegt und das objekt hat den ort schon geändert, aber noch 
//den meinen namen. die oma wird sich aber wundern, wenn sie die für mich 
//bestimmten pakete vom orion-versand bekommt. 
}

//den meinen namen. die oma wird sich aber wundern, wenn sie die für mich 
//bestimmten pakete vom orion-versand bekommt.

Ich vermute mal dass sich das nichtmehr ermitteln lassen wird.
Das Copy & Swap Idiom ist ja mit an Sicherheit grenzender Wahrscheinlichkeit schon älter als C++.
Wenn man es weit genug auslegt geht das in die Urgeschichte der Menschheit zurück, lange bevor es Computer gab.

Wo sollte man das noch brauchen? Wo hast du außerhalb vom Computer Operatorüberladung?

Und wenn es das schon vorher gab, wann ist einer auf die Idee gekommen, dass man das bei C++ braucht?
Und wieso findet man es in so wenig Frameworks? z.B.
QByteArray
http://www.koders.com/cpp/fid379C1B6DC09294E1484E7D9790E06891E714737C.aspx?s=cdef%3Aparser
QString
http://www.koders.com/cpp/fidFE1F7EFDF0758981038967272E930C0DEEC0DAD4.aspx?s=cdef%3Aparser
kein swap im ganzen Code.
Kennt das keiner?

nicht sein schrieb:

mit an Sicherheit grenzender Wahrscheinlichkeit schon älter als C++. Wenn man es weit genug auslegt geht das in die Urgeschichte der Menschheit zurück, lange bevor es Computer gab.

Wo sollte man das noch brauchen? Wo hast du außerhalb vom Computer Operatorüberladung?

Naja, der Mönch sagt, ich will erst das Buch komplett kopieren und dann mit dem Nachbarkloster gegen leeres Papier tauschen, statt seitenweise Kuddelmuddel zu machen.
Aber schon der Urzeitmensch sagte, ich will erst das Mammut totmachen, und es dann reiholen und den Müll raustragen, sonst gibt es nur Kuddelmuddel.
Irgendwo dazwischen, davor oder danach mögen die Urgründe des Copy&Spap liegen, wenn man es so weit sehen will.
Natürlich war das Copy&Swap in C++ gemeint, das dürfte nicht älter als C++ sein. Wikipedia sagt afair, RAII sei Stuppis Erfindung.

nicht sein schrieb:

mit an Sicherheit grenzender Wahrscheinlichkeit schon älter als C++. Wenn man es weit genug auslegt geht das in die Urgeschichte der Menschheit zurück, lange bevor es Computer gab.

Wo sollte man das noch brauchen? Wo hast du außerhalb vom Computer Operatorüberladung?

Naja, der Mönch sagt, ich will erst das Buch komplett kopieren und dann mit dem Nachbarkloster gegen leeres Papier tauschen, statt seitenweise Kuddelmuddel zu machen.
Aber schon der Urzeitmensch sagte, ich will erst das Mammut totmachen, und es dann reiholen und den Müll raustragen, sonst gibt es nur Kuddelmuddel.
Irgendwo dazwischen, davor oder danach mögen die Urgründe des Copy&Spap liegen, wenn man es so weit sehen will.

Da wird aber nicht wirklich ein Swap in ein temporäres Objekt gemacht. Die Seiten eines Buches werden ja nicht überschrieben. Da müsstest du ja zwei Bücher haben und die Buchstaben tauschen oder sowas. Und wer weiß schon, ob beim Buchstaben tauschen nicht doch eine Exception fliegt.

Und wer weiß schon, ob beim Buchstaben tauschen nicht doch eine Exception fliegt.

Das wichtigste am copy&swap ist ja, dass swap nothrow ist!

#include <algorithm>

struct Test
{
        int member;
        Test() : member(10) {
        }
        Test( const Test& other ) {
                member = other.member;
        }
        Test& operator =( const Test& other ) {
                Test tmp(other);
                std::swap( *this, tmp );
                return *this;
        }
};

int main() {
        Test t1, t2;
        t2 = t1;
}

segfaultet hier...
Da ist eine private Swap-Funktion besser, die hat Zugriff auf die Member und kann diese einzeln swappen.

using std::swap;
swap(*this, tmp);

und:

template<typename T>
struct swappable
{
  friend void swap(T& lhs, T& rhs)
  {
    lhs.swap(rhs);
  }
};

struct test : swappable<test>
{
  void swap(test& other)
  {
    /*...*/
  }
};

#if defined(NO_ADL_SWAP)
void std::swap(test& lhs, test& rhs)
{
  lhs.swap(rhs);
}
#endif

swap zu überladen ist hier auch laut standard kein problem - aber wenn templates ins spiel kommen ist es eine spezialisierung und die ist laut standard streng genommen nicht gestattet - aber imho sowohl bei der msvc-standard-lib als auch bei der gcc-lib nötig.
bei der gcc-lib müsste man so gar noch iter_swap irgendwie überladen - auch wenn ich gerade keine ahnung habe, wie das gehen sollte...

bb

swap zu überladen ist hier auch laut standard kein problem - aber wenn templates ins spiel kommen ist es eine spezialisierung und die ist laut standard streng genommen nicht gestattet

Umgekehrt. Spezilisierung ist zulässig, soweit eigene Typen involviert sind. Überladung hingegen nicht (in C++0x wird das iirc etwas gelockert).

unskilled schrieb:

swap zu überladen ist hier auch laut standard kein problem - aber wenn templates ins spiel kommen ist es eine spezialisierung und die ist laut standard streng genommen nicht gestattet

Umgekehrt. Spezilisierung ist zulässig, soweit eigene Typen involviert sind. Überladung hingegen nicht (in C++0x wird das iirc etwas gelockert).

oh - ich sollte nicht immer so lang schlafen, dann wär ich auch nicht immer so verpeilt ;o)
danke für die richtigstellung^^

bb