Як перевантажити std :: swap ()

std::swap()використовується багатьма контейнерами std (наприклад, std::listта std::vector) під час сортування та рівномірного призначення.

Але реалізація std swap()дуже узагальнена і досить неефективна для користувацьких типів.

Таким чином, ефективність може бути досягнута шляхом перевантаження std::swap()за допомогою конкретного типу. Але як це можна реалізувати, щоб його використовували контейнери std?

Правильний спосіб перевантажити своп - це записати його в тому ж просторі імен, що і те, що ви заміняєте, щоб його можна було знайти за допомогою аргументованого пошуку (ADL) . Особливо легко зробити це:

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

Увага Mozza314

Ось моделювання ефектів загального std::algorithmвиклику std::swapта надання користувачеві можливості здійснювати їх обмін у просторі імен std. Оскільки це експеримент, це моделювання використовується namespace expзамість 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);
}

Для мене це виводить:

generic exp::swap

Якщо ваш компілятор роздруковує щось інше, він неправильно здійснює "двофазний пошук" для шаблонів.

Якщо ваш компілятор відповідає (будь-якому із C ++ 98/03/11), він дасть той самий вихід, який я показав. І в цьому випадку трапиться саме те, чого ти боїшся. І введення вашого swapпростору імен std( exp) не зупинило його.

Ми з Дейвом обидва члени комітету і працюємо над цією областю стандарту протягом десятиліття (і не завжди узгоджуємо один з одним). Але це питання було врегульовано давно, і ми обидва погоджуємось, як воно було врегульовано. Не зважайте на думку експерта / відповідь Дейва в цій галузі на власну небезпеку.

Ця проблема з'явилася на світ після публікації C ++ 98. Починаючи з 2001 року, ми з Дейвом почали працювати в цій галузі . І це сучасне рішення:

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

Вихід:

swap(A, A)

Оновлення

Зроблено спостереження, що:

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

}

працює! То чому б не використати це?

Розглянемо випадок, що ваш Aшаблон шаблону:

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

Тепер це більше не працює. :-(

Таким чином, ви можете помістити swapв простір імен std і змусити його працювати. Але ви повинні пам'ятати , щоб помістити swapв Aпростір імен «S для випадку , коли у вас є шаблон: A<T>. І оскільки обидва випадки спрацюють, якщо ви помістите swapв Aпростір імен, просто запам'ятати (а також навчити інших) просто робити це одним способом.

Вам не дозволяється (за стандартом C ++) перевантажувати std :: swap, однак вам спеціально дозволено додавати спеціалізовані шаблони для власних типів у область імен std. Напр

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

то звичаї в контейнерах std (і деінде) виберуть вашу спеціалізацію замість загальної.

Також зауважте, що надання своп базового класу не є досить хорошим для похідних типів. Наприклад, якщо у вас є

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

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

це буде працювати для базових класів, але якщо ви спробуєте поміняти двома похідними об'єктами, він використовуватиме загальну версію з std, оскільки шаблонна заміна точно відповідає (і це дозволяє уникнути проблеми лише заміни 'базових' частин похідних об'єктів ).

ПРИМІТКА. Я оновив це, щоб видалити неправильні біти з моєї останньої відповіді. D'oh! (дякую puetzk та j_random_hacker за вказівку на це)

Хоча це правильно, що зазвичай не слід додавати речі до простору імен std ::, додавання спеціалізованих шаблонів для визначених користувачем типів спеціально дозволено. Перевантаження функцій немає. Це тонка різниця :-)

17.4.3.1/1 Не визначено для програми C ++ для додавання декларацій або визначень до std простору імен або просторів імен з std простору імен, якщо інше не вказано. Програма може додати спеціалізацію шаблонів для будь-якого стандартного шаблону бібліотеки до простору імен std. Така спеціалізація (повна або часткова) стандартної бібліотеки призводить до невизначеної поведінки, якщо декларація не залежить від визначеного користувачем імені зовнішнього зв’язку і якщо спеціалізація шаблонів не відповідає стандартним вимогам бібліотеки до вихідного шаблону.

Спеціалізація std :: swap виглядатиме так:

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

Без шаблону <> біт це буде перевантаження, яка не визначена, а не спеціалізація, яка дозволена. @ Уілка пропонує підхід до зміни простору імен за замовчуванням, можливо, працює з кодом користувача (завдяки пошуку Koenig, віддаючи перевагу версії, що не містить простору імен), але це не гарантується, і насправді це не передбачається (реалізація STL повинна використовувати повністю -кваліфікований std :: своп).

Існує нитка на comp.lang.c ++. Модератор з довгим обговорення теми. Більшість це, однак, про часткову спеціалізацію (що в даний час немає хорошого способу зробити).