Jak przeciążać std:: swap()

Attention Mozza314

Oto symulacja efektów ogólnego std::algorithm wywołania std::swap, a użytkownik dostarcza swap w przestrzeni nazw std. Ponieważ jest to eksperyment, ta symulacja używa namespace exp zamiast 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 wypisuje coś innego, to nie implementuje poprawnie "dwufazowego wyszukiwania" szablonów.

Jeśli twój kompilator jest zgodny (z którymkolwiek z C++98/03/11), wtedy da to samo wyjście, które pokazałem. I w takim przypadku dokładnie to, czego się obawiasz, stanie się. I umieszczenie swap w przestrzeni nazw std (exp) nie powstrzymało to przed tym.

Dave i ja jesteśmy członkami komisji i pracujemy w tym obszarze standardu od dekady (i nie zawsze w zgodzie ze sobą). Ale ta kwestia została rozwiązana przez długi czas i oboje zgadzamy się co do tego, jak została rozwiązana. Lekceważ eksperta Dave ' a opinia / odpowiedź w tej dziedzinie na własne ryzyko.

Ten numer wyszedł na jaw po opublikowaniu C++98. Od około 2001 roku Dave i ja zaczęliśmy pracować w tym obszarze . I 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);
}

Wyjście to:

swap(A, A)

Update

Zauważono, że:

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

}

Rozważ przypadek, że Twój A jest 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);
}

Więc możesz umieścić swap w przestrzeni nazw std i mieć to działa. Ale musisz pamiętać, aby umieścić swap w przestrzeni nazw A W przypadku, gdy masz szablon: A<T>. A ponieważ oba przypadki zadziałają, jeśli umieścisz swap w przestrzeni nazw A, po prostu łatwiej jest zapamiętać (i nauczyć innych) robić to w ten sposób.

Nie możesz (przez standard C++) przeciążać std:: swap, jednak możesz dodawać specjalizacje szablonów dla własnych typów do przestrzeni nazw std. Np.

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

Wtedy zwyczaje w kontenerach std (i gdziekolwiek indziej) wybiorą Twoją specjalizację zamiast ogólnej.

Zauważ również, że dostarczenie implementacji klasy bazowej swapu nie jest wystarczająco dobre dla Twoich 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 bazy klasy, ale jeśli spróbujesz zamienić dwa pochodne obiekty, użyje on wersji generycznej ze std, ponieważ template swap jest dokładnie dopasowany (i pozwala uniknąć problemu zamiany tylko "podstawowych" części obiektów pochodnych).

Uwaga: zaktualizowałem to, aby usunąć złe bity z mojej ostatniej odpowiedzi. D ' Oh! (dzięki puetzk i j_random_hacker za wskazanie tego)

Chociaż jest poprawne, że nie powinno się dodawać rzeczy do przestrzeni nazw std::, dodawanie specjalizacji szablonów dla typów zdefiniowanych przez użytkownika jest szczególnie dozwolone. Przeciążenie funkcji nie jest. To subtelna różnica: -)

17.4.3.1/1 Dla programu C++ nie jest zdefiniowane dodawanie deklaracji lub definicji do przestrzeni nazw std lub przestrzeni nazw z przestrzenią nazw std, chyba że określone. Program może dodawać szablony specjalizacji dla dowolnych biblioteka standardowa szablon do przestrzeni nazw std. Taka specjalizacja (całkowita lub częściowa) biblioteka standardowa daje wynik nieokreślony zachowanie, chyba że deklaracja zależy od zdefiniowanej przez użytkownika nazwy linkowania zewnętrznego i chyba że specjalizacja szablonu spełnia standardowe wymagania biblioteczne dla oryginalnego szablonu.

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

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

Bez szablonu bit byłby przeciążeniem, które jest niezdefiniowane, a nie specjalizacja, która jest dozwolona. Sugerowane przez @ Wilka podejście do zmiany domyślnej przestrzeni nazw może działać z kodem użytkownika (ze względu na to, że Koenig lookup preferuje wersję bez przestrzeni nazw), ale nie jest gwarantowane i tak naprawdę nie powinno (implementacja STL powinna używać w pełni kwalifikowanej STD:: swap).

Istnieje wątek na komp.lang.c++.moderowany z długi temat. Większość z nich dotyczy jednak częściowej specjalizacji (która jest obecnie nie jest to dobry sposób).