Jak przeładować std :: swap ()

std::swap()jest używany przez wiele kontenerów standardowych (takich jak std::listi std::vector) podczas sortowania, a nawet przypisywania.

Jednak standardowa implementacja programu swap()jest bardzo uogólniona i raczej nieefektywna dla typów niestandardowych.

W ten sposób wydajność można uzyskać przez przeciążenie std::swap()implementacją specyficzną dla niestandardowego typu. Ale jak można go zaimplementować, aby był używany przez kontenery standardowe?

Właściwym sposobem na przeciążenie zamiany jest zapisanie go w tej samej przestrzeni nazw, w której się zamieniasz, tak aby można go było znaleźć za pomocą wyszukiwania zależnego od argumentów (ADL) . Szczególnie łatwą rzeczą jest:

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);
        // ...
    }
};

Uwaga Mozza 314

Oto symulacja efektów std::algorithmwywołania ogólnego std::swapi sytuacji, w której użytkownik udostępnia swap w przestrzeni nazw std. Ponieważ jest to eksperyment, w tej symulacji namespace expzamiast 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);
}

Dla mnie to drukuje:

generic exp::swap

Jeśli Twój kompilator drukuje coś innego, oznacza to, że nie implementuje poprawnie „wyszukiwania dwufazowego” dla szablonów.

Jeśli twój kompilator jest zgodny (z którymkolwiek z C ++ 98/03/11), to da to samo wyjście, które pokazuję. I w takim przypadku wydarzy się dokładnie to, czego się obawiasz. Umieszczenie twojego swapw przestrzeni nazw std( exp) nie powstrzymało tego.

Dave i ja jesteśmy członkami komitetu i zajmujemy się tym obszarem normy od dziesięciu lat (i nie zawsze w porozumieniu). Ale ta kwestia została rozstrzygnięta od dawna i oboje zgadzamy się, jak została rozwiązana. Zignoruj ​​opinię / odpowiedź Dave'a w tej dziedzinie na własne ryzyko.

Ten problem wyszedł na jaw po opublikowaniu C ++ 98. Od około 2001 roku Dave i ja zaczęliśmy pracować w tej dziedzinie . A to jest nowoczesne rozwiązanie:

// 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);
}

Wynik to:

swap(A, A)

Aktualizacja

Stwierdzono, że:

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

}

Pracuje! Dlaczego więc tego nie użyć?

Rozważ przypadek, że Twój Ajest szablonem klasy:

// 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);
}

Teraz to już nie działa. :-(

Więc możesz wstawić swapstd przestrzeni nazw i sprawić, by działało. Ale trzeba pamiętać, aby umieścić swapw A„s nazw dla przypadku, gdy masz szablon: A<T>. A ponieważ w obu przypadkach będzie działać, jeśli umieścić swapw A„s nazw, to jest po prostu łatwiejsze do zapamiętania (a uczyć innych) po prostu zrób to, że jeden sposób.

Nie możesz (zgodnie ze standardem C ++) przeciążać std :: swap, jednak możesz w szczególności dodawać specjalizacje szablonów dla własnych typów do przestrzeni nazw std. Na przykład

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

wtedy zastosowania w kontenerach std (i gdziekolwiek indziej) wybiorą twoją specjalizację zamiast ogólnej.

Należy również pamiętać, że zapewnienie implementacji klasy bazowej wymiany nie jest wystarczające dla typów pochodnych. Np. Jeśli masz

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

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

to zadziała dla klas bazowych, ale jeśli spróbujesz zamienić dwa obiekty pochodne, użyje wersji ogólnej ze standardowego, ponieważ zamiana szablonowa jest dokładnym dopasowaniem (i pozwala uniknąć problemu zamiany tylko części "bazowych" twoich obiektów pochodnych ).

UWAGA: zaktualizowałem to, aby usunąć niewłaściwe bity z mojej ostatniej odpowiedzi. D'oh! (dzięki puetzk i j_random_hacker za wskazanie tego)

Chociaż prawdą jest, że generalnie nie należy dodawać rzeczy do przestrzeni nazw std ::, dodawanie specjalizacji szablonów dla typów zdefiniowanych przez użytkownika jest szczególnie dozwolone. Przeciążanie funkcji nie jest. To subtelna różnica :-)

17.4.3.1/1 Jest niezdefiniowane dla programu C ++, aby dodawać deklaracje lub definicje do przestrzeni nazw lub przestrzeni nazw z przestrzenią nazw, chyba że określono inaczej. Program może dodać specjalizacje szablonów dla dowolnego standardowego szablonu biblioteki do standardowej przestrzeni nazw. Taka specjalizacja (pełna lub częściowa) biblioteki standardowej skutkuje niezdefiniowanym zachowaniem, chyba że deklaracja zależy od zdefiniowanej przez użytkownika nazwy powiązania zewnętrznego i chyba, że ​​specjalizacja szablonu spełnia wymagania biblioteki standardowej dla oryginalnego szablonu.

Specjalizacja std :: swap wyglądałaby następująco:

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

Bez bitu template <> byłoby to przeciążenie, które jest nieokreślone, a nie specjalizacja, która jest dozwolona. @ Wilka sugerowane podejście do zmiany domyślnej przestrzeni nazw może działać z kodem użytkownika (z powodu wyszukiwania Koeniga preferującego wersję bez przestrzeni nazw), ale nie jest to gwarantowane, a tak naprawdę nie powinno (implementacja STL powinna używać w pełni -qualified std :: swap).

Istnieje wątek na comp.lang.c ++. Moderowany z długą dyskusją na ten temat. Większość z nich dotyczy jednak częściowej specjalizacji (na którą obecnie nie ma dobrego sposobu).