Item 25: 考虑写出一个不抛出异常的 swap函数
标准程序库中的swap行为:
namespace std {
template<typename T> // typical implementation of std::swap;
void swap(T& a, T& b) // swaps a's and b's values
{
T temp(a);
a = b;
b = temp;
}
}
只要你的类型支持拷贝(通过拷贝构造函数和拷贝赋值运算符),缺省的 swap 实现就会帮助置换对象,而不需要你做任何特别的支持工作。
但缺省的swap函数涉及三个对象的拷贝:从 a 到 temp,从 b 到 a,以及从 temp 到 b。对一些类型来说,这些复制动作是没有必要的。最主要的就是采用pimpl(pointer to implementation), “以指针指向一个对象,内含真正数据“的这种类型。
如:
class WidgetImpl { // class for Widget data;
public: // details are unimportant
...
private:
int a, b, c; // possibly lots of data -
std::vector<double> v; // expensive to copy!
...
};
class Widget { // class using the pimpl idiom
public:
Widget(const Widget& rhs);
Widget& operator=(const Widget& rhs) // to copy a Widget, copy its
{ // WidgetImpl object. For
... // details on implementing
*pImpl = *(rhs.pImpl); // operator= in general,
... // see Items 10, 11, and 12.
}
...
private:
WidgetImpl *pImpl; // ptr to object with this
}; // Widget's data
为了交换这两个 Widget 对象的值,我们实际要做的就是交换它们的 pImpl 指针,但是缺省的交换算法没有办法知道这些。它不仅要拷贝三个 Widgets,而且还有三个 WidgetImpl 对象,效率太低了。
当交换 Widgets 的是时候,我们应该告诉 std::swap 我们打算做什么,执行交换的方法就是交换它们内部的 pImpl 指针。这种方法的正规说法是:针对 Widget 特化 std::swap(specialize std::swap for Widget)。下面是一个基本的想法,虽然在这种形式下它还不能通过编译:
namespace std {
template<> // this is a specialized version
void swap<Widget>(Widget& a, // of std::swap for when T is
Widget& b) // Widget; this won't compile
{
swap(a.pImpl, b.pImpl); // to swap Widgets, just swap
} // their pImpl pointers
}
可是,就像我说的,这个函数还不能编译。那是因为它试图访问 a 和 b 内部的 pImpl 指针,而它们是 private 的。我们可以将我们的特化声明为友元,但是惯例是不同的:让 Widget 声明一个名为 swap 的 public 成员函数去做实际的交换,然后特化 std::swap 去调用那个成员函数:
class Widget { // same as above, except for the
public: // addition of the swap mem func
...
void swap(Widget& other)
{
using std::swap; // the need for this declaration
// is explained later in this Item
swap(pImpl, other.pImpl); // to swap Widgets, swap their
} // pImpl pointers
...
};
namespace std {
template<> // revised specialization of
void swap<Widget>(Widget& a, // std::swap
Widget& b)
{
a.swap(b); // to swap Widgets, call their
} // swap member function
}
这个不仅能够编译,而且和 STL 容器保持一致,所有 STL 容器都既提供了 public swap 成员函数,又提供了 std::swap 的特化来调用这些成员函数。
stl中vector的swap实现:(SGI STL 3.3)
std::swap:
template <class _Tp>
inline void swap(_Tp& __a, _Tp& __b) {
__STL_REQUIRES(_Tp, _Assignable);
_Tp __tmp = __a;
__a = __b;
__b = __tmp;
}
vector的public swap:(其实就是交换三个_Tp* 指针既可)
void swap(vector<_Tp, _Alloc>& __x) {
__STD::swap(_M_start, __x._M_start);
__STD::swap(_M_finish, __x._M_finish);
__STD::swap(_M_end_of_storage, __x._M_end_of_storage);
}
特化swap:(调用vector类的public swap成员)
template <class _Tp, class _Alloc>
inline void swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
{
__x.swap(__y);
}
!!给自己的模板类添加swap:
假设 Widget 和 WidgetImpl 是类模板,而不是类,或许因此我们可以参数化存储在 WidgetImpl 中的数据类型:(其实这就和stl vector的行为一样)
template<typename T>
class WidgetImpl { ... };
template<typename T>
class Widget { ... };
在 Widget 中加入一个 swap 成员函数(如果我们需要,在 WidgetImpl 中也加一个)就像以前一样容易,但我们特化 std::swap 时会遇到麻烦。这就是我们要写的代码:
namespace std {
template<typename T>
void swap<Widget<T> >(Widget<T>& a, // error! illegal code!
Widget<T>& b)
{ a.swap(b); }
}
这看上去非常合理,但它是非法的。我们试图部分特化(partially specialize)一个函数模板(std::swap),但是尽管 C++ 允许类模板的部分特化(partial specialization),但不允许函数模板这样做。这样的代码不能编译.
当我们想要“部分特化”一个函数模板时,通常做法是简单地增加一个重载。看起来就像这样:(pure like std::vector的实现办法)
namespace std {
template<typename T> // an overloading of std::swap
void swap(Widget<T>& a, // (note the lack of "<...>" after
Widget<T>& b) // "swap"), but see below for
{ a.swap(b); } // why this isn't valid code
}
通常,重载函数模板确实很不错,但是 std 是一个特殊的 namespace,规则对它也有特殊的待遇。它认可完全特化 std 中的模板,但它不认可在 std 中增加新的模板(也包括类,函数,以及其它任何东西)。std 的内容由 C++ 标准化委员会单独决定,并禁止我们对他们做出的决定进行增加。而且,禁止的方式使你无计可施。打破这条禁令的程序差不多的确可以编译和运行,但它们的行为是未定义的。如果你希望你的软件有可预期的行为,你就不应该向 std 中加入新的东西。
正确的做法是声明一个非成员 swap 来调用成员 swap,只是不再将那个非成员函数声明为 std::swap 的特化或重载。例如,如果我们的 Widget 相关机能都在 namespace WidgetStuff 中,它看起来就像这个样子:
namespace WidgetStuff {
... // templatized WidgetImpl, etc.
template<typename T> // as before, including the swap
class Widget { ... }; // member function
...
template<typename T> // non-member swap function;
void swap(Widget<T>& a, // not part of the std namespace
Widget<T>& b)
{
a.swap(b);
}
}
然后,假设你写了这样一个函数模板来交换两个对象的值:
template<typename T>
void doSomething(T& obj1, T& obj2)
{
...
swap(obj1, obj2);
...
}
当编译器看到这个 swap 调用,他会寻找正确的 swap 版本来调用。C++ 的名字查找规则确保能找到在全局 namespace 或者与 T 同一个 namespace 中的 T 专用的 swap。(例如,如果 T 是 namespace WidgetStuff 中的 Widget,编译器会利用参数依赖查找(argument-dependent lookup)找到 WidgetStuff 中的 swap。)如果 T 专用 swap 不存在,编译器将使用 std 中的 swap,这归功于此函数中的 using declaration 使 std::swap 在此可见。尽管如此,相对于通用模板,编译器还是更喜欢 T 专用的 std::swap 的特化,所以如果 std::swap 对 T 进行了特化,则特化的版本会被使用。
采用如下的版本可以保证以上的调用顺序:
如果 T 专用版本存在,你希望调用它,如果它不存在,就回过头来调用 std 中的通用版本。如下这样就可以符合你的希望:
template<typename T>
void doSomething(T& obj1, T& obj2)
{
using std::swap; // make std::swap available in this function
...
swap(obj1, obj2); // call the best swap for objects of type T
...
}
总结:
首先,如果 swap 的缺省实现为你的类或类模板提供了可接受的性能,你不需要做任何事。任何试图交换你的类型的对象的人都会得到缺省版本的支持,而且能工作得很好。
第二,如果 swap 的缺省实现效率不足(这几乎总是意味着你的类或模板使用了某种 pimpl idiom 的变种),就按照以下步骤来做:
1. 提供一个能高效地交换你的类型的两个对象的值的 public 的 swap 成员函数。出于我过一会儿就要解释的动机,这个函数应该永远不会抛出异常。
2. 在你的类或模板所在的同一个 namespace 中提供一个非成员的 swap。用它调用你的 swap 成员函数。
3. 如果你写了一个类(不是类模板),就为你的类特化 std::swap。用它也调用你的 swap 成员函数。
最后,如果你调用 swap,请确保在你的函数中包含一个 using declaration 使 std::swap 可见,然后在调用 swap 时不使用任何 namespace 限定条件。
成员版swap绝不能抛出异常!!(后继条款29对此说明)