Boost开发指南-4.5swap

swap

boost::swap是对标准库里的std::swap 的增强和泛化，为交换两个变量（可以是int等内置数据类型，或者是类实例、容器）的值提供了便捷的方法。

为了使用boost::swap，需要包含头文件<boost/swap.hpp>，即

#include<boost/swap.hpp>

原理

C++98标准中的std::swap()

template<typename T>
void swap(T&a, T& b)
{T tmp(a);a = b;b = temp;
}

从代码中可以看出，std::swap()要求交换的对象必须是可拷贝构造和可拷贝赋值的，它提供的是最通用同时也是效率最低的方法，需要进行一次复制构造和两次赋值操作，如果交换的对象很大，那么运行代价会相当昂贵。

C++11标准中使用转移语义对std::swap()进行了优化，避免了拷贝的代价。

template<typename T>
void swap(T& a, T& b)
{T tmp = std::move(a); //move, 把a偷到tmpa = std::move(b); //move, 把b偷到ab = std::move(tmp); //move, 把tmp偷到b
}

但不是所有的类都实现了自己的转移构造和赋值函数的，而且编译器的支持也是个必须考虑的问题，所以对于我们自己写的类，最好能够实现优化的swap()来提高效率。

解决方案有两种：第一种方案是直接利用函数重载，编写一个同名的 swap_函数，这个swap()再调用类内部的高效成员交换函数，这样编译器在编译时就不会使用std::swap()。第二种方案是使用ADrR查找模板特化的 std::swap。这两种方案就是 boost::swap的工作原理。

boost::swap查找有无针对类型T的std::swap()的特化或者通过ADL查找模板特化的 swap()，如果有则调用，如果两种查找都失败时则退化为std::swap()。此外，boost::swap还增加了一个很实用的功能——对C++内建数组交换的支持（已经被收入C++11标准）。

boost::swap()函数的声明是：

template<class T1, class T2>
void swap(T1& left, T2& right);

由于boost::swap()与std::swap()同名，所以我们不能使用using语句打开boost名字空间，应该总以boost名字空间限定的方式调用它。

交换数组

boost::swap可以直接交换两个数组的内容，但要求参与交换的两个数组必须具有相同的长度。下面的代码使用标准库算法 fill_n 将两个数组分别赋值为5和20，然后调用boost::swap()交换：

int a1[10]; //两个数组
int a2[10];std::fill_n(a1, 10, 5); //fill_n赋初始值
std::fill_n(a2, 10, 20);boost::swap(a1, a2); //交换两个数组的内容

boost::swap交换数组内容的实现很简单，它使用了一个for循环，对数组中的每个元素调用单个元素版的boost::swap完成整个数组内容的交换。在上面的代码执行后a1中元素的值将为20，而a2中元素的值将为5。

如果企图用boost::swap 交换两个长度不相同的数组，那么将无法通过编译：

int a1[10], a2[12]; //两个长度不相同的数组
boost::swap(a1, a2); //发生编译错误

特化std::swap

接下来我们用一个简单的三维空间的点 point 作为例子，示范模板特化的方法使用boost::swap。它实现了内部高效的交换函数：

class point
{int x, y, z;
public:explicit point(int a = 0, int b = 0, int c = 0) :x(a), y(b), z(c) {}void print()const{cout << x << "," << y << "," << z << endl;}void swap(point& p) //内置高效交换函数{std::swap(x, p.x);std::swap(y, p.y);std::swap(z, p.z);cout << "inner swap" << endl;}
};

特化std::swap()的方法需要向std名字空间添加自定义函数：

namespace std
{template<>void swap(point &x, point &y){ x.swap(y); }
}int main()
{point a(1,2,3), b(4,5,6);cout << "std::swap" << endl;std::swap(a,b); //调用std::swapcout << "boost::swap" << endl;boost::swap(a, b); //调用boost::swap
}

由于我们在名字空间特化了std::swap，因此，boost::swap与std::swap的效果相同，都使用了特化后的swap函数。

特化ADL可找到的swap

依然使用刚才的point类，但这次我们不变动std名字空间，而是在全局域实现swap函数：

void swap(point &x, point &y) //全局域的swap函数
{ x.swap(y); }int main()
{point a(1,2,3), b(4,5,6);cout << "std::swap" << endl;std::swap(a,b); //调用std::swapcout << "boost::swap" << endl;boost::swap(a,b); //调用boost::swap
}

这段代码的运行结果与之前的特化std::swap有明显不同，std::swap使用了标准的交换操作，而 boost::swap通过ADL 规则找到了全局名字空间的特化交换函数，实现了高效的交换。

如果读者担心在全局名字空间编写自由函数 swap 会造成名字“污染”，则可以把特化的swap加入到boost名字空间，或者其他ADL可以找到的名字空间。

代码示例

#include <iostream>
using namespace std;#include <boost/core/swap.hpp>
#include <boost/assign.hpp>//
void case1()
{using namespace boost::assign;int a1[10];int a2[10];std::fill_n(a1, 10, 5);std::fill_n(a2, 10, 20);boost::swap(a1, a2);}//
class point
{int x, y, z;
public:explicit point(int a = 0, int b = 0, int c = 0) :x(a), y(b), z(c) {}void print()const{cout << x << "," << y << "," << z << endl;}void swap(point& p){std::swap(x, p.x);std::swap(y, p.y);std::swap(z, p.z);cout << "inner swap" << endl;}
};//namespace std
//{
//template<>
//void swap(point &x, point &y)               //模板特化swap函数
//{   x.swap(y);}
//}namespace boost {void swap(point& x, point& y){x.swap(y);}
}void case2()
{point a(1, 2, 3), b(4, 5, 6);cout << "std::swap" << endl;std::swap(a, b);cout << "boost::swap" << endl;boost::swap(a, b);
}//int main()
{case1();case2();
}