Como sobrecarregar std :: swap ()

std::swap()é usado por muitos contêineres std (como std::liste std::vector) durante a classificação e até mesmo a atribuição.

Mas a implementação padrão do swap()é muito generalizada e bastante ineficiente para tipos personalizados.

Assim, a eficiência pode ser obtida sobrecarregando std::swap()com uma implementação específica de tipo personalizado. Mas como você pode implementá-lo para que seja usado pelos contêineres std?

A maneira certa de sobrecarregar a troca é gravá-la no mesmo namespace do que você está trocando, para que possa ser encontrada por meio de pesquisa dependente de argumento (ADL) . Uma coisa particularmente fácil de fazer é:

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

Atenção Mozza314

Aqui está uma simulação dos efeitos de uma std::algorithmchamada genérica std::swape fazendo com que o usuário forneça sua troca no namespace std. Como se trata de um experimento, esta simulação usa em namespace expvez 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);
}

Para mim, isso imprime:

generic exp::swap

Se o seu compilador imprimir algo diferente, ele não está implementando corretamente a "pesquisa em duas fases" para modelos.

Se o seu compilador estiver em conformidade (com qualquer um dos C ++ 98/03/11), ele fornecerá a mesma saída que mostrei. E, nesse caso, exatamente o que você teme que aconteça, realmente acontece. E colocar seu swapno namespace std( exp) não impediu que isso acontecesse.

Dave e eu somos membros do comitê e temos trabalhado nessa área do padrão por uma década (e nem sempre de acordo um com o outro). Mas essa questão foi resolvida há muito tempo, e ambos concordamos em como isso foi resolvido. Ignore a opinião / resposta de especialista de Dave nesta área por sua própria conta e risco.

Este problema veio à tona após a publicação do C ++ 98. A partir de 2001, Dave e eu começamos a trabalhar nessa área . E esta é a solução 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);
}

O resultado é:

swap(A, A)

Atualizar

Foi feita uma observação que:

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

}

trabalho! Então, por que não usar isso?

Considere o caso em que seu Aé um modelo 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);
}

Agora não funciona novamente. :-(

Portanto, você pode swapinserir o namespace std e fazê-lo funcionar. Mas você precisa se lembrar de colocar swapno Anamespace 's para o caso quando você tem um modelo: A<T>. E uma vez que ambos os casos irá funcionar se você colocar swapem A's namespace, é apenas mais fácil de lembrar (e para ensinar aos outros) para fazê-lo apenas que uma maneira.

Você não tem permissão (pelo padrão C ++) para sobrecarregar std :: swap, no entanto, você está especificamente autorizado a adicionar especializações de modelo para seus próprios tipos ao namespace std. Por exemplo

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

então, os usos nos contêineres std (e em qualquer outro lugar) escolherão sua especialização em vez da geral.

Observe também que fornecer uma implementação de classe base de swap não é bom o suficiente para seus tipos derivados. Por exemplo, se você tem

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

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

isto funcionará para classes Base, mas se você tentar trocar dois objetos Derivados ele usará a versão genérica de std porque a troca modelada é uma correspondência exata (e evita o problema de trocar apenas as partes 'base' de seus objetos derivados )

NOTA: Eu atualizei isso para remover as partes erradas da minha última resposta. D'oh! (obrigado puetzk e j_random_hacker por apontar isso)

Embora seja correto que não se deva geralmente adicionar coisas ao std :: namespace, adicionar especializações de template para tipos definidos pelo usuário é especificamente permitido. Sobrecarregar as funções, não. Esta é uma diferença sutil :-)

17.4.3.1/1 É indefinido para um programa C ++ adicionar declarações ou definições ao namespace std ou namespaces com namespace std, a menos que especificado de outra forma. Um programa pode adicionar especializações de template para qualquer template de biblioteca padrão ao namespace std. Tal especialização (completa ou parcial) de uma biblioteca padrão resulta em um comportamento indefinido, a menos que a declaração dependa de um nome definido pelo usuário de ligação externa e a menos que a especialização de modelo atenda aos requisitos de biblioteca padrão para o modelo original.

Uma especialização de std :: swap ficaria assim:

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

Sem o bit template <>, seria uma sobrecarga, que é indefinida, ao invés de uma especialização, que é permitida. A abordagem sugerida de @Wilka para alterar o espaço de nomes padrão pode funcionar com o código do usuário (devido à pesquisa de Koenig preferir a versão sem espaço de nomes), mas não é garantido, e de fato não deveria funcionar (a implementação de STL deve usar o -qualificado std :: swap).

Há um tópico em comp.lang.c ++. Moderado com uma longa discussão sobre o assunto. A maior parte é sobre especialização parcial (o que atualmente não existe uma boa maneira de fazer).