Comment surcharger std :: swap ()

std::swap()est utilisé par de nombreux conteneurs std (tels que std::listet std::vector) pendant le tri et même l'affectation.

Mais l'implémentation std de swap()est très généralisée et plutôt inefficace pour les types personnalisés.

Ainsi, l'efficacité peut être gagnée en surchargeant std::swap()avec une implémentation spécifique de type personnalisé. Mais comment pouvez-vous l'implémenter pour qu'il soit utilisé par les conteneurs std?

La bonne façon de surcharger le swap est de l'écrire dans le même espace de noms que celui que vous échangez, afin qu'il puisse être trouvé via la recherche dépendante de l'argument (ADL) . Une chose particulièrement facile à faire est:

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

Attention Mozza314

Voici une simulation des effets d'un std::algorithmappel générique std::swap, et demandant à l'utilisateur de fournir son échange dans l'espace de noms std. Comme il s'agit d'une expérience, cette simulation utilise à la namespace expplace de 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);
}

Pour moi, ceci s'imprime:

generic exp::swap

Si votre compilateur imprime quelque chose de différent, il n'implémente pas correctement la "recherche en deux phases" pour les modèles.

Si votre compilateur est conforme (à l'un des C ++ 98/03/11), alors il donnera la même sortie que je montre. Et dans ce cas, exactement ce que vous craignez se produira. Et mettre votre swapdans namespace std( exp) ne l'a pas empêché de se produire.

Dave et moi sommes tous deux membres du comité et travaillons dans ce domaine de la norme depuis une décennie (et pas toujours en accord l'un avec l'autre). Mais cette question est réglée depuis longtemps et nous sommes tous les deux d'accord sur la façon dont elle a été réglée. Ne tenez pas compte de l'opinion / de la réponse d'expert de Dave dans ce domaine à vos risques et périls.

Ce problème est apparu après la publication de C ++ 98. À partir de 2001, Dave et moi avons commencé à travailler dans ce domaine . Et voici la solution moderne:

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

La sortie est:

swap(A, A)

Mettre à jour

Une observation a été faite que:

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

}

travaux! Alors pourquoi ne pas l'utiliser?

Considérez le cas où vous Aêtes un modèle de 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);
}

Maintenant, cela ne fonctionne plus. :-(

Vous pouvez donc mettre swapdans l'espace de noms std et le faire fonctionner. Mais vous devez vous rappeler de mettre swapdans Al'espace de nom » pour le cas où vous avez un modèle: A<T>. Et puisque les deux cas fonctionneront si vous mettez swapdans Al'espace de noms », il est tout simplement plus facile à retenir (et à d' autres enseignent) à faire juste que d' une façon.

Vous n'êtes pas autorisé (par le standard C ++) à surcharger std :: swap, mais vous êtes spécifiquement autorisé à ajouter des spécialisations de modèle pour vos propres types à l'espace de noms std. Par exemple

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

alors les utilisations dans les conteneurs std (et partout ailleurs) choisiront votre spécialisation au lieu de la généraliste.

Notez également que fournir une implémentation de classe de base de swap n'est pas suffisant pour vos types dérivés. Par exemple, si vous avez

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

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

cela fonctionnera pour les classes de base, mais si vous essayez d'échanger deux objets dérivés, il utilisera la version générique de std car le swap basé sur un modèle est une correspondance exacte (et cela évite le problème de ne permuter que les parties `` de base '' de vos objets dérivés ).

REMARQUE: j'ai mis à jour ceci pour supprimer les mauvais bits de ma dernière réponse. Oh! (merci puetzk et j_random_hacker pour l'avoir signalé)

Bien qu'il soit correct de ne pas généralement ajouter de choses à l'espace de noms std ::, l'ajout de spécialisations de modèle pour les types définis par l'utilisateur est spécifiquement autorisé. La surcharge des fonctions ne l'est pas. C'est une différence subtile :-)

17.4.3.1/1 Il n'est pas défini pour un programme C ++ d'ajouter des déclarations ou des définitions à l'espace de noms std ou aux espaces de noms avec l'espace de noms std, sauf indication contraire. Un programme peut ajouter des spécialisations de modèle pour tout modèle de bibliothèque standard à l'espace de noms std. Une telle spécialisation (complète ou partielle) d'une bibliothèque standard entraîne un comportement indéfini à moins que la déclaration ne dépende d'un nom de lien externe défini par l'utilisateur et à moins que la spécialisation de modèle ne réponde aux exigences de bibliothèque standard pour le modèle d'origine.

Une spécialisation de std :: swap ressemblerait à ceci:

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

Sans le bit template <>, ce serait une surcharge, qui n'est pas définie, plutôt qu'une spécialisation, qui est autorisée. @ L'approche suggérée par Wilka de changer l'espace de noms par défaut peut fonctionner avec le code utilisateur (en raison de la recherche Koenig préférant la version sans espace de noms) mais ce n'est pas garanti, et en fait n'est pas vraiment censée le faire (l'implémentation STL devrait utiliser pleinement -std :: swap qualifié).

Il existe un fil de discussion sur comp.lang.c ++. Animé par une longue discussion sur le sujet. Cependant, la plupart d'entre eux concernent une spécialisation partielle (ce qu'il n'y a actuellement aucun bon moyen de faire).