Есть несколько способов написать swap, некоторые лучше, чем другие. Со временем, однако, было найдено, что единственное определение работает лучше всего. Давайте рассмотрим, как мы можем подумать о написании swap функции.
Сначала мы видим, что контейнеры типа std::vector<> имеют функцию-член с одним аргументом swap, например:
struct vector
{
void swap(vector&) { /* swap members */ }
};
Естественно, наш класс тоже должен, верно? Ну не совсем. В стандартной библиотеке есть всевозможных ненужных вещей , и член swap является одним из них. Зачем? Пойдем дальше.
Что нам нужно сделать, так это определить, что канонично, и что нашему классу нужно , чтобы работать с ним. И канонический метод обмена с std::swap. Вот почему функции-члены бесполезны: они вообще не такие, как мы должны менять местами, и не имеют отношения к поведению std::swap.
Что ж, чтобы заставить std::swap работать, мы должны предоставить (а std::vector<> должен был предоставить) специализацию std::swap, верно?
namespace std
{
template <> // important! specialization in std is OK, overloading is UB
void swap(myclass&, myclass&)
{
// swap
}
}
Хорошо, это, безусловно, сработает в этом случае, но у него есть явная проблема: специализация функций не может быть частичной. То есть мы не можем специализировать шаблонные классы с этим, только с конкретными экземплярами:
namespace std
{
template <typename T>
void swap<T>(myclass<T>&, myclass<T>&) // error! no partial specialization
{
// swap
}
}
Этот метод работает иногда, но не всегда. Должен быть лучший способ.
Есть! Мы можем использовать функцию friend и найти ее через ADL:
namespace xyz
{
struct myclass
{
friend void swap(myclass&, myclass&);
};
}
Когда мы хотим что-то поменять, мы связываем † std::swap и затем делаем неквалифицированный вызов:
using std::swap; // allow use of std::swap...
swap(x, y); // ...but select overloads, first
// that is, if swap(x, y) finds a better match, via ADL, it
// will use that instead; otherwise it falls back to std::swap
Что такое friend функция? Вокруг этого района царит путаница.
До стандартизации C ++ функции friend выполняли что-то, называемое "внедрение имени друга", когда код вел себя , как если бы , если функция была написана в окружающем пространстве имен. Например, это были эквивалентные предварительные стандарты:
struct foo
{
friend void bar()
{
// baz
}
};
// turned into, pre-standard:
struct foo
{
friend void bar();
};
void bar()
{
// baz
}
Однако, когда ADL был изобретен, он был удален. Тогда функция friend может быть найдена только через через ADL; если вы хотите, чтобы это была свободная функция, ее нужно было объявить так ( см., например, ). Но вот! Возникла проблема.
Если вы просто используете std::swap(x, y), ваша перегрузка никогда не будет найдена, потому что вы явно сказали: «Смотрите в std, и больше нигде»! Вот почему некоторые люди предлагают написать две функции: одну как функцию, которую можно найти через ADL, а другую - для обработки явных std:: квалификаций.
Но, как мы видели, это не может работать во всех случаях, и мы в конечном итоге получаем ужасный беспорядок. Вместо этого идиоматическая перестановка пошла другим путем: вместо того, чтобы заставить классы обеспечивать std::swap, работа подменщиков состоит в том, чтобы убедиться, что они не используют квалифицированные swap, как описано выше. И это имеет тенденцию работать довольно хорошо, пока люди об этом знают. Но в этом-то и заключается проблема: необязательно использовать неквалифицированный вызов!
Чтобы сделать это проще, некоторые библиотеки, такие как Boost, предоставили функцию boost::swap, которая просто выполняет неквалифицированный вызов swap, с std::swap в качестве связанного пространства имен. Это помогает снова сделать все лаконичным, но это все еще облом.
Обратите внимание, что в C ++ 11 нет изменений в поведении std::swap, что, как я и другие ошибочно полагали, имело место. Если вас это укусило, читайте здесь .
Вкратце: функция-член - это просто шум, специализация уродлива и неполна, но функция friend завершена и работает. А когда вы меняете местами, используйте boost::swap или неквалифицированный swap с std::swap.
† Неформально с именем ассоциируется , если оно будет учитываться при вызове функции. Для деталей, прочитайте §3.4.2. В этом случае std::swap обычно не учитывается; но мы можем связать это (добавить его к набору перегрузок, рассматриваемых неквалифицированным swap), позволяя найти его.