Эффективное использование C++. 55 верных способов улучшить структуру и код ваших программ

*pimpl = *(rhs.pimpl); // см. в правилах 10, 11 и 12
...
}
...
private:
WidgetImpl *pimpl; // указатель на объект с данными
}; // этого Widget

Чтобы обменять значения двух объектов Widget, нужно лишь обменять значениями их указатели pimpl, но алгоритм swap по умолчанию об этом знать не может. Вместо этого он не только трижды выполнит операцию копирования Widget, но еще и три раза скопирует Widgetlmpl. Очень неэффективно!

А нам бы хотелось сообщить функции std::swap, что при обмене объектов Widget нужно обменять значения хранящихся в них указателей pimpl. И такой способ существует: специализировать std::swap для класса Widget. Ниже приведена основная идея, хотя в таком виде код не скомпилируется:

namespace std {
template <> // это специализированная версия
void swap<Widget>(Widget& a, // std::swap, когда T есть
Widget& b) // Widget; не скомпилируется
{
swap(a.pimpl, b.pimpl); // для обмена двух Widget просто
} // обмениваем их указатели pimpl
}

Строка «template <>» в начале функции говорит о том, что это полная специализация шаблона std::swap, а «<Widget>» после имени функции говорит о том, что это специализация для случая, когда T есть Widget. Другими словами, когда общий шаблон swap применяется к Widget, то должна быть использована эта реализация. Вообще-то не допускается изменять содержимое пространства имен std, но разрешено вводить полные специализации стандартных шаблонов (подобных swap) для созданных нами типов (например, Widget). Что мы и делаем.

Как я уже сказал, эта функция не скомпилируется. Дело в том, что она пытается получить доступ к указателям pimpl внутри a и b, а они закрыты. Мы можем объявить нашу специализацию другом класса, но соглашение требует поступить иначе: нужно объявить в классе Widget открытую функцию-член по имени swap, которая осуществит реальный обмен значениями, а затем специализация std::swap вызовет эту функцию-член:

class Widget { // все как раньше, за исключением
public: // добавления функции-члена swap
...
void swap(Widget& other)
{
using std::swap; // необходимость в этом объявлении
// объясняется далее
swap(pimpl, other.pimpl); // чтобы обменять значениями два объекта
} // Widget,обмениваем указатели pimpl
...
};
namespace std {
template <> // переделанная версия
void swap<Widget>(Widget& a, // std::swap
Widget& b)
{
a.swap(b); // чтобы обменять значениями Widget,
} // вызываем функцию-член swap
}

Этот вариант не только компилируется, но и полностью согласован с STL-контейнерами, каждый из которых предоставляет и открытую функцию-член swap, и специализированную версию std::swap, которая вызывает эту функцию-член.

Предположим, однако, что Widget и Widgetlmpl – это не обычные, а шаблонные классы. Возможно, это понадобилось для того, чтобы можно было параметризировать тип данных, хранимых в Widgetlmpl:

template <typename T>
class WidgetImpl {...};
template <typename T>
class Widget {...};

Поместить функцию-член swap в Widget (и при необходимости в Widgetlmpl) в этом случае так же легко, как и раньше, но мы сталкиваемся с проблемой, касающейся специализации std::swap. Вот что мы хотим написать:

namespace std {
template <typename T>
void swap<Widget<T>>(Widget<T>& a, // ошибка! Недопустимый код
Widget<T>& b)
{ a.swap(b);}
}

Выглядит совершенно разумно, но все равно неправильно. Мы пытаемся частично специализировать шаблон функции (std::swap), но, хотя C++ допускает частичную специализацию шаблонов класса, он не разрешает этого для шаблонов функций. Этот код не должен компилироваться (если только некоторые компиляторы не пропустят его по ошибке).

Когда вам нужно «частично специализировать» шаблон функции, лучше просто добавить перегруженную версию. Примерно так:

namespace std {
template <typename T>
void swap(Widget<T>& a, // перегрузка std::swap
Widget<T>& b) // (отметим отсутствие <...> после
{ a.swap(b);} // “swap”), далее объяснено, почему
} // этот код некорректен

Вообще, перегрузка шаблонных функций – нормальное решение, но std – это специальное пространство имен, и правила, которым оно подчиняется, тоже специальные. Можно полностью специализировать шаблоны в std, но нельзя добавлять в std новые шаблоны (или классы, или функции, или что-либо еще). Содержимое std определяется исключительно комитетом по стандартизации C++, и нам запрещено пополнять список того, что они решили включить туда. К сожалению, форма этого запрета может привести вас в смятение. Программы, которые нарушают его, почти всегда компилируются и исполняются, но их поведение не определено! Если вы не хотите, чтобы ваши программы вели себя непредсказуемым образом, то не должны добавлять ничего в std.

Что же делать? Нам по-прежнему нужен способ, чтобы разрешить другим людям вызывать swap и иметь более эффективную шаблонную версию. Ответ прост. Мы, как и раньше, объявляем свободную функцию swap, которая вызывает функцию-член swap, но не говорим, что это специализация или перегруженный вариант std::swap. Например, если вся функциональность, касающаяся Widget, находится в пространстве имен WidgetStuff, то это будет выглядеть так:

namespace WidgetStuff {
... // шаблонный WidgetImpl и т. п.