条款25:考虑写出一个不抛异常的swap函数

条款25:考虑写出一个不抛异常的swap函数
(Consider support for a non-throwing swap.)

内容:
swap函数就是相互交换两个对象的内容,标准程序库中已经提供了该函数的实现版本,其实现过程也是那么的如你预
期所愿:
namespace std{
template <typename T>
void swap(T& a,T& b)
{
T tempt(a);
a = b;
b = tempt;
}
}
但是这种实现版本对某些类型来说,效率上存在很大的问题,尤其面临那些对的性能要求很高的软件,这种实现版本
显然不能满足要求.这里我们所说的'某些类型'大体上指的是'以指针指向一个对象,内含真正数据'那种类型,这种
设计的常见的表现形式就是所谓的"pimpl"手法(条款31将提到).我们再来看一个例子:
class Window{ //这个class使用了pimpl手法
public:
Window(const Window& rhs);
Window& operator=(const Window& rhs){
...
*pImpl_ = *(rhs.pImpl_);
...
}
...
private:
class WindowImpl{
public:
...
private:
string title_;
std::vector<Window* > childList_;
};
WindowImpl* pImpl_;
};
如果用std::swap进行对两个Window对象进行交换的话,那么它不止复制三个Window还复制了三个WindowImpl对象,
非常缺乏效率.通常我们不能够(不被允许)改变std命名空间内的任何东西,但可以为标准templates制造特化版本,这里
我们可以为std::swap提供一个全特化版本来提高效率:
namespace std{
template<>
void swap<Window>(Window& a,Window& b){
swap(a.pImpl_,b.pImpl_);
}
}
但是这里遇到的问题是pImpl_是private域内成员变量,我们无法直接访问它,怎么办?我们的做法是构造一个member
swap的版本.
class Window{
public:
...
void swap(Window& other){
using std::swap;
swap(pImpl_,other.pImpl_);
}
...
};
namespace std{
template<>
void swap<Window>(Window& a,Window& b){
a.swap(b);
}
}
倘若这里的Window以及WindowImpl要都是class template而非class:
template<typename T>
class WindowImpl{...};
template<typename T>
class Window{...};
那么我们就不能这么写了:
namespace std{
template<typename T>
void swap<Window<T>>(Window<T>& lhs,Window<T>& rhs){
a.swap(b);
}
}
因为我们企图偏特化一个function template,但C++只允许对class template偏特化,在function template身上偏
特化是行不通的.那这么办?没有其它方法了吗?有!当你打算偏特化一个function template时,一般做法是简单地为它
添加一个重载版本,比如:
namespace std{
template<typename T>
void swap(Window<T>& lhs,Window<T>& rhs){ //这里是一个重载版本(没有<...>)
lhs.swap(rhs);
}
}
这样重载function templates没有问题,但std是个特殊的命名空间,你可以全特化std内的template,但你不能添加
心的template到std中,因为改命名空间内容完全由C++标准委员会决定,标准委员会禁止我们膨胀那些已经声明好的东
西.晕死,这也不行,那我们就自己创建命名空间不就行了:
namespace WindowStuff{
...
template<typename T>
class Window{...};
...
template<typename T>
void swap(Window<T>& lhs,Window<T>& rhs){
a.swap(b);
}
}
那接下来我们的客户如何使用呢?假设你正在写一个function template,其内需要置换两个对象值:
template<typename T>
void doSomething(T& obj1,T& ojb2){
using std::swap;
...
swap(obj1,obj2);
...
}
一旦编译器看到对swap的调用,它们便查找适当的swap并调用.如果T是Window并位于命名空间WindowStuff内的,
编译器会使用'参数依赖查找法'找到WindowStuff命名空间内的swap版本,如果该空间没有对应的swap版本,编译
器就使用std::swap(using的声明式让std::swap在函数内曝光),而在std空间内如果你提供了针对T的特化版本,编
译器就会挑中它,当然如果没有提供,那么编译器只有老老实实的调用那个一般化的swap版本的啰,呵呵.
现在来说一下我们的条款内容:成员版swap绝不可抛出异常.那是因为swap的一个最好的应用是帮助classes(和
class template)提供强烈的异常安全性保障.此约束只施行于成员版.
今天说的有点多了,如果没看懂的话,请慢慢消化.
请记住:
■ 当std::swap对你的类型效率不高时,提供一个swap成员函数,并确定这个函数不抛出异常.
■ 如果你提供一个member swap,也该提供一个non-member swap用来调用前者.对于classes(而非template),
也请特化std::swap.
■ 调用swap时应针对std::swap使用using声明式,然后调用swap并且不带任何""命名空间资格修饰.
■ 为"用户定义类型"进行std templates全特化是好的,但千万不要尝试在std内加入某些std而言全新的东西.