assign
许多情况下我们都需要为容器初始化或者赋值，填入大量的数据，比如初始错误代码和错误信息，或者是一些测试用的数据。在C++98中标准容器仅提供了容纳这些数据的方法，但填充的步骤却是相当地麻烦，必须重复调用insert()或者push_back()等成员函数，这正是boost.assign出现的理由。
assign库重载了赋值操作符operator+=、逗号操作符operator,和括号操作符operator()，可以用难以想象的简洁语法非常方便地对标准容器赋值或者初始化。在需要填入大量初值的地方很有用。C++11标准也提供类似功能的初始化列表，但功能没有assign库那么完备。
assign库位于名字空间 boost::assign，为了使用assign库，需要包含头文件<boost/assign.hpp>，它包含了大部分assign库的工具，即：
#include <boost/assign.hpp>
using namespace boost::tassign;
list_inserter
list_inserter是assign库中用来操作容器的工具类，它类似std::back_inserter，但增加了很多操作符重载和助手类来简化代码。
template< class Eunction >class list_inserter
{
public:
list_inserter& operator, (const T& r); //重载operator,
list_inserter& operator()(); //重载operator()
list_inserter& operator()(const T& r);
public: //重复输入数据操作
list_inserter& repeat(std::size_t sz, T r );
list_inserter& repeat_fun(std::size_t sz, Nullary_function fun);
list_inserter& range(SinglePassIterator first, SinglePassIterator last);
list_inserter& range(const singlePassRange& r);
private:
Function insert_;
};
list_inserter内部存储一个函数对象insert_用来操作容器，这个函数对象包装了容器的push_back、push_front等操作，例如：
list_inserter& operator,(const T& r) //重载operator,
{
insert_(r); //向容器添加元素
return *this; //返回自身的引用
}
list_inserter成员函数的另一个特点是返回*this，这使得它可以像标准流操作一样串联操作，达到简化代码的目的。
list_inserter还提供repeat/range函数来简化输入重复数据的工作。
使用operator+=
使用assign库时必须使用using 指示符，只有这样才能让重载的+=，等操作符在作用域内生效。例如：
#include <boost/assign.hpp>
int main()
{
using namespace boost::assign; //很重要,启用assign库的功能
vector<int> v; //标准向量容器
v += 1, 2, 3, 4, 5, 6 * 6; //用operator+=和,填入数据
set<string> s; //标准集合容器
s += "c", "cpp", "lua", "swift";
map<int, string> m; //标准映射容器
m += make_pair(1, "one"), make_pair(2, "two");
}
上面的代码示范了assign库操作标准容器的能力。+=操作符后可以接若干个可被容器容纳的元素，元素之间使用逗号分隔。元素不一定是常量，表达式或者函数调用也是可以接受的，只要其结果能够转换成容器可容纳的类型。比较特别的是 map容器，必须使用辅助函数make_pair()来生成容器元素，单纯地用括号把pair的两个成员括起来是无效的。
assign 库提供三个工厂函数push_back()、push_front()和insert()。这些函数可作用于拥有同名成员函数的容器，接受容器实例作为参数，创建对应的 list_inserter对象。
在名字空间 boost::assign里 assign库为标准容器重载了operator+=，调用push_back()或insert()函数，形式是：
inline list_inserter operator+=(C& c, V v)
{
return push_back(c)(v); //对于关联容器则是insert函数
}
operator+=作用于容器时调用工厂函数push_back()，产生一个list_inserter对象，以这个对象作为起点，随后的operator()和operator，就会依次执行，使用push_back()或insert()向容器插入数据。由于list_inserter重载了很少使用的逗号操作符，所以函数的调用得到了极大的简化。
operator+=很好用，但有一点遗憾，assign库仅提供了对C++98标准容器(vector、list、set等）的重载，要操作其他类型的容器(如Boost容器）只能依据其原理自行实现。
使用operator()
operator+=仅作用于标准容器，而且在处理map容器时也显得有些麻烦，所以我们可以直接使用工厂函数insert() /push_front()/push_back()，直接利用他们返回的list_inserter对象来填入数据。
int main()
{
using namespace boost::assign;
vector<int> v;
push_back(v)(1)(2)(3)(4)(5); //使用puch_back工厂函数
list<string> l;
push_front(l)("c")("cpp")("lua")("swift"); //使用push_front工厂函数
forward_list<string> fl; //C++11的单向链表
push_front(l)("matrix")("reload"); //使用push__front工厂函数
set<double> s;
insert(s)(3.14)(0.618)(1.732); //使用insert工厂函数
map<int, string> m;
insert(m)(1, "one")(2, "two"); //使用insert工厂函数
}
这段代码与使用operator+=没有太多的不同。对于拥有push_back()或push_front ()成员函数的容器(vector、list、deque)，可以调用assign::push_back()或assign::push_front()，而对于set和map，则只能使用assign::insert()。
operator()的好处是可以在括号中使用多个参数，这对于 map这样的元素是由多个值组成的类型非常方便，避免了make_pair()函数的使用。而且如果括号中没有参数，那么list_inserter 将调用容器元素的缺省构造函数填入一个缺省值，逗号操作符则不能这样做。
括号操作符也可以与逗号等操作符配合使用，写法更简单，有时甚至看起来不像是合法的C++代码(但的确是完全正确的C++代码)，例如：
using namespace boost::assign;
vector<int> v;
push_back(v), 1, 2, 3, 4, 5;
push_back(v)(6), 7, 64 / 8, (9), 10; //v=[1 2 3 4 5 6 7 8 9 10]
for (auto& x : v)
cout << x << ",";
cout << endl;
deque<string> d;
push_front(d)() = "breath", "of", "the", "wild";
assert(d.size() == 5); //d=['wild', 'the', 'of', 'breath', '']
generic_list
list_inserter解决了对容器的赋值问题，但有的时候我们需要在容器构造的时候就完成数据的填充，这种方式较赋值更为高效。
C++11标准引入了初始化列表std::initializer_list，而 boost.assign库则提供功能类似的generic_list，它的类摘要如下：
template<class T>
class generic_list
{
public:
iterator begin() const; //类似容器的接口
iterator end() const;
bool empty() const;
size_type size() const;
generic_list& operator,(const Ty& u); //重载operator,
generic_list&operator()(); //重载operator()
generic_list&operator()(const Ty& u);
public: //重复输入数据操作
generic_list& repeat(std::size_t sz, U u);
generic_list& repeat_fun(std::size_t sz, Nullary_function fun);
generic_list& range(singlePassIterator first, singlePassIterator last);
generic_list& range(const singlePassRange& r);
public: //容器转换
operator container(const;
Container to_container(Container& c) const;
adapter_converter to_adapter() const;
Adapter to_adapter(Adapter& a) const;
Array to_array(Array& a) const;
};
与list_inserter类似，generic_list也重载了逗号和括号操作符，因为要在初始化时与容器互操作，它还增加了一些容器操作函数。
generic_list内部使用std::deque 存储元素，大多数操作都转换为 deque 的push_back()，例如：
generic_list& operator,(const Ty& u) //重载operator,
{
this->push_back(u); //push_back添加元素
return *this; //返回自身的引用
}
初始化容器
assign库提供三个工厂函数list_of()、map_list_of()/pair_list_of()和tuple_list_of()，它们能够产生 generic_list 对象，然后我们就可以像list_inserter一样使用operator()和 operator，来填充数据。
因为generic_list提供到容器类型的隐式转型操作，所以它可以赋值给任意容器，当然我们也可以显式调用容器转换函数。
list_of()函数的声明是：
inline generic_list<T> list_of();
inline generic_list<T> list_of(const T&t);
它的用法与之前的insert()、push_back()等函数相似：
int main()
{
using namespace boost::assign;
vector<int> v = list_of(1)(2)(3)(4)(5);
// v = [1, 2, 3, 4, 5]
deque<string> d =
(list_of("power")("bomb"), "phazon", "suit"); //注意括号和逗号的使用
// d = [power bomb phazon suit]
set<int> s = (list_of(10), 20, 30, 40, 50); //注意括号和逗号的使用
// s = {10 20 30 40 50}
map<int, string> m = list_of(make_pair(1, "one"))(make_pair(2, "two"));
// m = [(1, “one”) (2, “two”)]
}
list_of()函数可以全部使用括号操作符，也可以把括号与逗号结合起来，但使用后者时需要将整个list_of表达式用括号括起来，否则会使编译器无法推导出list_of的类型而无法赋值。
上面的代码对应的C++11标准代码是
vector<int> v = {1,2,3,4,5};
deque<string> d = {"power", "bomb", "phazon", "suit"};
set<int> s = {10, 20, 30, 40, 50};
map<int, string> m = {{1, "one"},{2, "two"}};
两段代码比较起来，虽然assign库的略显麻烦，但胜在对C++98和C++11的兼容性。
使用list_of()处理map容器不是很方便，于是map_list_of()/pair_list_of()应运而生，map_list_of()可以接受两个参数，然后自动构造std::pair对象插入map 容器，pair_list_of()则纯粹是map_list_of的同义词，两者的用法功能完全相同。
map_list_of()和pair_list_of()的基本形式如下：
template<class Key, class T>
map_lists_of(const Key& k, const T& t); //key, value
template<class F, class S>
pair_list_of(const F&f, const S&s)
{
return map_list_of(f, s);
}
下面的代码演示了map_list_of的用法：
map<int, int> m1 = map_list_of(1, 2)(3, 4)(5, 6);
//m1 = [(1, 2)(3, 4)(5, 6)]
map<int, string> m2 = map_list_of(1, "one")(2, "two");
//m2 = [(1, "one")(2, "two")]
减少重复输入
在填充数据时会遇到输入重复数据的问题，如果用之前的方法要写大量的重复代码，很麻烦，也容易造成多写或少写的错误。list_inserter 和 generic_list 都提供成员函数repeat()、repeat_fun()和range()来减轻工作量。
这三个函数的简要声明如下：
list& repeat(std::size_t sz, U u);
list& repeat_fun(std::size_t sz, Nullary_function fun);
list& range(SinglePassIterator first, SinglePassIterator last);
list& range(const SinglePassRange& r);
repeat()函数把第二个参数作为要填入的值，重复第一个参数指定的次数，与vectorvdeque等容器的构造函数很相似；repeat_fun()函数同样重复第一个参数的次数，但第二个参数是个无参的函数或函数对象，它返回填入的数值；range()函数则可以把一个序列里的全部或者部分元素插入到另一个序列里。
它们同样也返回列表list_inserter或generic_list，所以可以串联进operator()和operator，操作序列里。
示范它们用法的代码如下：
#include <boost/assign.hpp>
#include <cstdlib> //for rand()
void case5()
{
using namespace boost::assign;
vector<int> v = list_of(1).repeat(3, 2)(3)(4)(5);
//v = 1,2,2,2,3,4,5
for (auto& x : v)
cout << x << ",";
cout << endl;
multiset<int> ms;
insert(ms).repeat_fun(5, &rand).repeat(2, 1), 10;
//ms = x,x,x,x,x,1,1,10
for (auto& x : ms)
cout << x << ",";
cout << endl;
deque<int> d;
push_front(d).range(v.begin(), v.begin() + 5);
//d = 3,2,2,2,1
for (auto& x : d)
cout << x << ",";
cout << endl;
}
操作非标准容器
assign库不仅支持全部8个标准容器（vector、string、deque、 list、set、multiset、map、multimap），也对容器适配器提供了适当的支持，包括 stack、queue和priority_queue。
因为这三个容器适配器没有push_back/push_front函数，所以assign库提供push()函数来赋值，但stack 可以使用 operator+=。初始化的list_of表达式最后则使用to_adapter()成员函数来适配到非标准容器。如果使用逗号操作符还需要把整个表达式用括号括起来，才能使用点号操作符调用to_adapter()。
示范assign库应用于容器适配器的代码如下：
#include <stack>
#include <queue>
int main()
{
using namespace boost::assign;
stack<int> stk = (list_of(1), 2, 3).to_adapter();
stk += 4, 5, 6;
for (; !stk.empty();) //输出stack的内容
{
cout << stk.top() << " ";
stk.pop();
}
cout << endl;
queue<string> q = (list_of("china")("us")("uk")).
repeat(2, "russia").to_adapter();
push(q)("germany");
for (; !q.empty();) //输出queue的内容
{
cout << q.front() << " ";
q.pop();
}
cout << endl;
priority_queue<double> pq = (list_of(1.414), 1.732, 2.236).to_adapter();
push(pq), 3.414, 2.71828;
for (; !pq.empty();) //输出优先队列的内容
{
cout << pq.top() << " ";
pq.pop();
}
}
其他议题
assign 库还有两个类似功能的函数ref_list_of()和 cref_list_of()，这两个函数接受变量的引用作为参数来创建初始化列表，较list_of()的内部 deque效率更高，但用法略微麻烦，例如：
using namespace boost::assign;
int a = 1, b = 2, c = 3;
vector<int> v = ref_list_of<3>(a)(b)(c);
assert(v.size() == 3);
代码示例
#include <iostream>
using namespace std;
#include <boost/assign.hpp>
//using namespace boost::assign;
//
void case1()
{
using namespace boost::assign;
vector<int> v;
v += 1, 2, 3, 4, 5, 6 * 6;
for (auto& x : v)
cout << x << ",";
cout << endl;
set<string> s;
s += "c", "cpp", "lua", "swift";
for (auto& x : s)
cout << x << ",";
cout << endl;
map<int, string> m;
m += make_pair(1, "one"), make_pair(2, "two");
}
//
#include <forward_list>
void case2()
{
using namespace boost::assign;
vector<int> v;
push_back(v)(1)(2)(3)(4)(5);
list<string> l;
push_front(l)("c")("cpp")("lua")("swift");
forward_list<string> fl;
push_front(l)("matrix")("reload");
set<double> s;
insert(s)(3.14)(0.618)(1.732);
map<int, string> m;
insert(m)(1, "one")(2, "two");
}
//
void case3()
{
using namespace boost::assign;
vector<int> v;
push_back(v), 1, 2, 3, 4, 5;
push_back(v)(6), 7, 64 / 8, (9), 10;
for (auto& x : v)
cout << x << ",";
cout << endl;
deque<string> d;
push_front(d)() = "breath", "of", "the", "wild";
assert(d.size() == 5);
for (auto& x : d)
cout << x << ",";
cout << endl;
}
//
void case4()
{
using namespace boost::assign;
vector<int> v = list_of(1)(2)(3)(4)(5);
// v = [1, 2, 3, 4, 5]
deque<string> d =
(list_of("power")("bomb"), "phazon", "suit");
// d = [power bomb phazon suit]
set<int> s = (list_of(10), 20, 30, 40, 50);
// s = {10 20 30 40 50}
map<int, string> m = list_of(make_pair(1, "one"))(make_pair(2, "two"));
// m = [(1, “one”) (2, “two”)]
map<int, int> m1 = map_list_of(1, 2)(3, 4)(5, 6);
//m1 = [(1, 2)(3, 4)(5, 6)]
map<int, string> m2 = map_list_of(1, "one")(2, "two");
//m2 = [(1, "one")(2, "two")]
}
//
#include <cstdlib> //for rand()
void case5()
{
using namespace boost::assign;
vector<int> v = list_of(1).repeat(3, 2)(3)(4)(5);
//v = 1,2,2,2,3,4,5
for (auto& x : v)
cout << x << ",";
cout << endl;
multiset<int> ms;
insert(ms).repeat_fun(5, &rand).repeat(2, 1), 10;
//ms = x,x,x,x,x,1,1,10
for (auto& x : ms)
cout << x << ",";
cout << endl;
deque<int> d;
push_front(d).range(v.begin(), v.begin() + 5);
//d = 3,2,2,2,1
for (auto& x : d)
cout << x << ",";
cout << endl;
}
//
#include <stack>
#include <queue>
void case6()
{
using namespace boost::assign;
stack<int> stk = (list_of(1), 2, 3).to_adapter();
stk += 4, 5, 6;
for (; !stk.empty();)
{
cout << stk.top() << " ";
stk.pop();
}
cout << endl;
queue<string> q = (list_of("china")("us")("uk")).
repeat(2, "russia").to_adapter();
push(q)("germany");
for (; !q.empty();)
{
cout << q.front() << " ";
q.pop();
}
cout << endl;
priority_queue<double> pq = (list_of(1.414), 1.732, 2.236).to_adapter();
push(pq), 3.414, 2.71828;
for (; !pq.empty();)
{
cout << pq.top() << " ";
pq.pop();
}
}
//
void case7()
{
using namespace boost::assign;
int a = 1, b = 2, c = 3;
vector<int> v = ref_list_of<3>(a)(b)(c);
assert(v.size() == 3);
}
//
int main()
{
case1();
case2();
case3();
case4();
case5();
case6();
case7();
}
