Überladen von std :: swap ()

std::swap()wird von vielen Standardcontainern (wie std::listund std::vector) beim Sortieren und sogar beim Zuweisen verwendet.

Die Standardimplementierung von swap()ist jedoch sehr verallgemeinert und für benutzerdefinierte Typen eher ineffizient.

Somit kann Effizienz durch Überladen std::swap()mit einer benutzerdefinierten typspezifischen Implementierung erzielt werden. Aber wie können Sie es implementieren, damit es von den Standardcontainern verwendet wird?

Der richtige Weg, um Swap zu überladen, besteht darin, ihn in denselben Namespace wie den Swap zu schreiben, damit er über die argumentabhängige Suche (ADL) gefunden werden kann . Eine besonders einfache Sache ist:

class X
{
    // ...
    friend void swap(X& a, X& b)
    {
        using std::swap; // bring in swap for built-in types

        swap(a.base1, b.base1);
        swap(a.base2, b.base2);
        // ...
        swap(a.member1, b.member1);
        swap(a.member2, b.member2);
        // ...
    }
};

Achtung Mozza314

Hier ist eine Simulation der Auswirkungen eines generischen std::algorithmAufrufs std::swap, bei der der Benutzer seinen Swap im Namespace std bereitstellt. Da dies ein Experiment ist, verwendet diese Simulation namespace expanstelle von namespace std.

// simulate <algorithm>

#include <cstdio>

namespace exp
{

    template <class T>
    void
    swap(T& x, T& y)
    {
        printf("generic exp::swap\n");
        T tmp = x;
        x = y;
        y = tmp;
    }

    template <class T>
    void algorithm(T* begin, T* end)
    {
        if (end-begin >= 2)
            exp::swap(begin[0], begin[1]);
    }

}

// simulate user code which includes <algorithm>

struct A
{
};

namespace exp
{
    void swap(A&, A&)
    {
        printf("exp::swap(A, A)\n");
    }

}

// exercise simulation

int main()
{
    A a[2];
    exp::algorithm(a, a+2);
}

Für mich druckt dies aus:

generic exp::swap

Wenn Ihr Compiler etwas anderes druckt, implementiert er die "Zwei-Phasen-Suche" für Vorlagen nicht korrekt.

Wenn Ihr Compiler konform ist (mit C ++ 98/03/11), gibt er dieselbe Ausgabe aus, die ich zeige. Und in diesem Fall passiert genau das, was Sie befürchten. Und das Einfügen Ihres swapNamespace std( exp) hat dies nicht verhindert.

Dave und ich sind beide Komiteemitglieder und arbeiten seit einem Jahrzehnt in diesem Bereich des Standards (und sind uns nicht immer einig). Dieses Problem ist jedoch schon lange gelöst, und wir sind uns beide einig, wie es gelöst wurde. Ignorieren Sie Daves Expertenmeinung / Antwort in diesem Bereich auf eigene Gefahr.

Dieses Problem trat nach der Veröffentlichung von C ++ 98 auf. Ab ungefähr 2001 begannen Dave und ich, diesen Bereich zu bearbeiten . Und das ist die moderne Lösung:

// simulate <algorithm>

#include <cstdio>

namespace exp
{

    template <class T>
    void
    swap(T& x, T& y)
    {
        printf("generic exp::swap\n");
        T tmp = x;
        x = y;
        y = tmp;
    }

    template <class T>
    void algorithm(T* begin, T* end)
    {
        if (end-begin >= 2)
            swap(begin[0], begin[1]);
    }

}

// simulate user code which includes <algorithm>

struct A
{
};

void swap(A&, A&)
{
    printf("swap(A, A)\n");
}

// exercise simulation

int main()
{
    A a[2];
    exp::algorithm(a, a+2);
}

Ausgabe ist:

swap(A, A)

Aktualisieren

Es wurde festgestellt, dass:

namespace exp
{    
    template <>
    void swap(A&, A&)
    {
        printf("exp::swap(A, A)\n");
    }

}

funktioniert! Warum also nicht das benutzen?

Stellen Sie sich den Fall vor, dass es sich bei Ihrer AKlasse um eine Klassenvorlage handelt:

// simulate user code which includes <algorithm>

template <class T>
struct A
{
};

namespace exp
{

    template <class T>
    void swap(A<T>&, A<T>&)
    {
        printf("exp::swap(A, A)\n");
    }

}

// exercise simulation

int main()
{
    A<int> a[2];
    exp::algorithm(a, a+2);
}

Jetzt funktioniert es nicht mehr. :-(

Sie können also den swapNamespace std eingeben und es funktionieren lassen. Aber Sie müssen sich daran zu erinnern setzen swapin A‚s - Namensraum für den Fall , wenn Sie eine Vorlage haben: A<T>. Und da beiden Fälle werden funktionieren , wenn Sie setzen swapin A‚s - Namensraum ist es einfach leichter zu merken (und zu lehren andere) zu tun es einfach , dass ein Weg.

Es ist Ihnen (nach dem C ++ - Standard) nicht gestattet, std :: swap zu überladen. Sie dürfen jedoch speziell dem std-Namespace Vorlagenspezialisierungen für Ihre eigenen Typen hinzufügen. Z.B

namespace std
{
    template<>
    void swap(my_type& lhs, my_type& rhs)
    {
       // ... blah
    }
}

Dann wählen die Verwendungen in den Standardcontainern (und anderswo) Ihre Spezialisierung anstelle der allgemeinen.

Beachten Sie auch, dass die Bereitstellung einer Basisklassenimplementierung von Swap für Ihre abgeleiteten Typen nicht gut genug ist. ZB wenn du hast

class Base
{
    // ... stuff ...
}
class Derived : public Base
{
    // ... stuff ...
}

namespace std
{
    template<>
    void swap(Base& lha, Base& rhs)
    {
       // ...
    }
}

Dies funktioniert für Basisklassen. Wenn Sie jedoch versuchen, zwei abgeleitete Objekte auszutauschen, wird die generische Version von std verwendet, da der Vorlagenaustausch genau übereinstimmt (und das Problem vermieden wird, nur die Basisteile Ihrer abgeleiteten Objekte auszutauschen ).

HINWEIS: Ich habe dies aktualisiert, um die falschen Bits aus meiner letzten Antwort zu entfernen. D'oh! (danke puetzk und j_random_hacker für den hinweis)

Während es richtig ist, dass man dem std :: -Namensraum im Allgemeinen nichts hinzufügen sollte, ist das Hinzufügen von Vorlagenspezialisierungen für benutzerdefinierte Typen ausdrücklich zulässig. Überladen der Funktionen ist nicht. Das ist ein subtiler Unterschied :-)

17.4.3.1/1 Es ist für ein C ++ - Programm undefiniert, Deklarationen oder Definitionen zum Namespace std oder zu Namespaces mit dem Namespace std hinzuzufügen, sofern nicht anders angegeben. Ein Programm kann dem Namespace std Vorlagenspezialisierungen für jede Standardbibliotheksvorlage hinzufügen. Eine solche (vollständige oder teilweise) Spezialisierung einer Standardbibliothek führt zu einem undefinierten Verhalten, es sei denn, die Deklaration hängt von einem benutzerdefinierten Namen der externen Verknüpfung ab und die Vorlagenspezialisierung erfüllt nicht die Standardbibliotheksanforderungen für die ursprüngliche Vorlage.

Eine Spezialisierung von std :: swap würde folgendermaßen aussehen:

namespace std
{
    template<>
    void swap(myspace::mytype& a, myspace::mytype& b) { ... }
}

Ohne das Template <> -Bit wäre es eher eine undefinierte Überladung als eine zulässige Spezialisierung. @ Wilkas Vorschlag, den Standard-Namespace zu ändern, funktioniert möglicherweise mit Benutzercode (da Koenig Lookup die Version ohne Namespace bevorzugt), dies ist jedoch nicht garantiert und sollte es auch nicht sein (die STL-Implementierung sollte den vollständigen verwenden) -qualifizierter std :: swap).

Es gibt einen Thread zu comp.lang.c ++. Moderiert mit einer langen Diskussion des Themas. Das meiste davon handelt jedoch von einer teilweisen Spezialisierung (was derzeit nicht gut möglich ist).