Come sovraccaricare std :: swap ()

std::swap()viene utilizzato da molti contenitori std (come std::liste std::vector) durante l'ordinamento e anche l'assegnazione.

Ma l'implementazione standard di swap()è molto generalizzata e piuttosto inefficiente per i tipi personalizzati.

Pertanto l'efficienza può essere ottenuta sovraccaricando std::swap()con un'implementazione specifica del tipo personalizzata. Ma come puoi implementarlo in modo che venga utilizzato dai contenitori std?

Il modo giusto per sovraccaricare lo scambio è scriverlo nello stesso spazio dei nomi di quello che stai scambiando, in modo che possa essere trovato tramite la ricerca dipendente dagli argomenti (ADL) . Una cosa particolarmente facile da fare è:

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

Attenzione Mozza314

Ecco una simulazione degli effetti di una std::algorithmchiamata generica std::swape che l'utente fornisce il proprio scambio nello spazio dei nomi std. Poiché si tratta di un esperimento, questa simulazione utilizza namespace expinvece di 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);
}

Per me questo stampa:

generic exp::swap

Se il tuo compilatore stampa qualcosa di diverso, non sta implementando correttamente la "ricerca in due fasi" per i modelli.

Se il tuo compilatore è conforme (a uno qualsiasi di C ++ 98/03/11), allora darà lo stesso output che mostro. E in quel caso accade esattamente quello che temi che accada. E mettere il tuo swapin namespace std( exp) non ha impedito che accadesse.

Dave ed io siamo entrambi membri del comitato e lavoriamo in quest'area dello standard da un decennio (e non sempre in accordo l'uno con l'altro). Ma la questione è stata risolta da molto tempo e siamo entrambi d'accordo su come è stata risolta. Ignora l'opinione / risposta degli esperti di Dave in questo settore a tuo rischio e pericolo.

Questo problema è emerso dopo la pubblicazione di C ++ 98. A partire dal 2001, Dave e io abbiamo iniziato a lavorare in quest'area . E questa è la soluzione moderna:

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

L'output è:

swap(A, A)

Aggiornare

È stata fatta un'osservazione che:

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

}

lavori! Allora perché non usarlo?

Considera il caso in cui il tuo Aè un modello di classe:

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

Ora non funziona più. :-(

Quindi potresti inserire lo swapspazio dei nomi std e farlo funzionare. Ma è necessario ricordarsi di mettere swapin A's spazio dei nomi per il caso in cui si dispone di un modello: A<T>. E dal momento che entrambi i casi, funzionano se si mette swapin A's spazio dei nomi, è solo più facile da ricordare (e ad altri insegnano) per farlo solo che un modo.

Non sei autorizzato (dallo standard C ++) a sovraccaricare std :: swap, tuttavia sei specificamente autorizzato ad aggiungere specializzazioni di modello per i tuoi tipi allo spazio dei nomi std. Per esempio

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

quindi gli usi nei contenitori std (e in qualsiasi altro luogo) sceglieranno la tua specializzazione invece di quella generale.

Si noti inoltre che fornire un'implementazione della classe base di swap non è sufficiente per i tipi derivati. Ad esempio, se hai

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

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

questo funzionerà per le classi Base, ma se provi a scambiare due oggetti derivati ​​userà la versione generica da std perché lo scambio basato su modellièuna corrispondenza esatta (ed evita il problema di scambiare solo le parti 'base' dei tuoi oggetti derivati ).

NOTA: l'ho aggiornato per rimuovere i bit sbagliati dalla mia ultima risposta. D'oh! (grazie puetzk e j_random_hacker per averlo fatto notare)

Sebbene sia corretto che non si debba generalmente aggiungere cose allo spazio dei nomi std ::, l'aggiunta di specializzazioni di template per i tipi definiti dall'utente è specificamente consentita. Il sovraccarico delle funzioni non lo è. Questa è una sottile differenza :-)

17.4.3.1/1 Non è definito per un programma C ++ aggiungere dichiarazioni o definizioni allo spazio dei nomi std o spazi dei nomi con spazio dei nomi std se non diversamente specificato. Un programma può aggiungere specializzazioni di modello per qualsiasi modello di libreria standard allo spazio dei nomi std. Una tale specializzazione (completa o parziale) di una libreria standard risulta in un comportamento indefinito a meno che la dichiarazione non dipenda da un nome definito dall'utente di collegamento esterno e a meno che la specializzazione del modello non soddisfi i requisiti della libreria standard per il modello originale.

Una specializzazione di std :: swap sarebbe simile a:

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

Senza il bit template <> sarebbe un sovraccarico, che non è definito, piuttosto che una specializzazione, che è consentita. L'approccio suggerito da @ Wilka per modificare lo spazio dei nomi predefinito potrebbe funzionare con il codice utente (a causa della ricerca di Koenig che preferisce la versione senza spazio dei nomi) ma non è garantito, e in effetti non dovrebbe farlo (l'implementazione STL dovrebbe usare completamente -qualified std :: swap).

C'è un thread su comp.lang.c ++. Moderato con una lunga discussione sull'argomento. Tuttavia, la maggior parte riguarda la specializzazione parziale (cosa che al momento non è possibile fare).