Boost源码剖析之：容器赋值-assign

相信大多数使用STL的人都是为了使用里面的容器，使用vector、list、map的程序员对以下代码可以说是非常熟悉了：

1. vector i_v;
   
2. i_v.push_back(1);
   
3. i_v.push_back(2);
   
4. i_v.push_back(3);
   
5. i_v.push_back(4);
   
6. i_v.push_back(5);

复制代码

挺枯燥，是吧？用boost的assignment库可以让这一过程简洁得多：

1. #include "boost/assign/std/vector.hpp"
   
2. using namespace boost::assign;
   
3. 
   
4. vector i_v;
   
5. i_v += 1,2,3,4,5;

复制代码

效果与上面的程序一致，可读性却好很多，看上去有点“脚本语言”的感觉了。
对于关联容器，也有类似的便洁方法：

1. #include "boost/assign/list_inserter.hpp"
   
2. #include "string"
   
3. using namespace std;
   
4. using namespace boost::assign;map months;
   
5. 
   
6. insert( months )
   
7. ( "january", 31 )( "february", 28 )
   
8. ( "march", 31 )( "april", 30 )
   
9. ( "may", 31 )( "june", 30 )
   
10. ( "july", 31 )( "august", 31 )
    
11. ( "september", 30 )( "october", 31 )
    
12. ( "november", 30 )( "december", 31 );

复制代码

分析assign的源代码，以vector为例，先看:

1. //assign/std/vector.hpp:
   
2. 
   
3. template< class V, class A, class V2 >
   
4. inline list_inserter< assign_detail::call_push_back< std::vector >, V >
   
5. operator+=( std::vector & c, V2 v )
   
6. {
   
7.         return push_back( c )( v );
   
8. }

复制代码

操作符+=已被重载，它的任务是返回一个list_inserter类，这是assign中的核心类之一。再看push_back，它也没有实质性的动作，只是创建一个list_inserter然后返回它。

1. template< class C >
   
2. inline list_inserter< assign_detail::call_push_back ,
   
3. BOOST_DEDUCED_TYPENAME C::value_type >
   
4. push_back( C& c )
   
5. {
   
6.         static BOOST_DEDUCED_TYPENAME C::value_type* p = 0;
   
7.         return make_list_inserter( assign_detail::call_push_back ( c ), p );
   
8. }

复制代码

这里的call_push_back(c)实际是创建一个类call_push_back的实例，以使生成的list_inserter能够知道自己该怎样进行操作。

1. template< class C >
   
2. class call_push_back
   
3. {
   
4.         C& c_; public: call_push_back( C& c ) : c_( c )
   
5.         { }
   
6.         
   
7.         template< class T > void operator()( T r )
   
8.         {
   
9.                 c_.push_back( r );
   
10.         }
    
11. };

复制代码

make_list_inserter和STL中的make_pair类似，都是用于包装实现类的，真正的实现是利用list_inserter。

1. template< class Function, class Argument >
   
2. inline list_inserter
   
3. make_list_inserter( Function fun, Argument* )
   
4. {
   
5.         return list_inserter( fun );
   
6. }

复制代码

list_inserter重载了+=操作符，所以才有 i_v+=1,2,3,4,5 这种写法。可以看出 push_back函数返回一个list_inserter，对应例子，i_v+=1变为push_back(i_v)(1),其中的 push_back(i_v) (注意：不包括后面的“（1）”！) 变为make_list_inserter(call_push_back(i_v), 0),最后make_list_inserter返回的是list_inserter< call_push_back, int>实例，现在可以加上后面的“(1)”了，由于list_inserter重载了“()”操作符,所以此时值1才被list_inserter接收。
那数字间的逗号又是怎么处理的呢？大家还记不记得 std::cout<< 1 << 2 << 3; 此处的<<和assign中的逗号其实是一个道理，<<操作符返回一个iostream,而逗号操作符返回一个 list_inserter 。“+=”操作符返回第一个list_inserter，其它的逗号“跟进”:

1. template< class Function, class Argument = assign_detail::forward_n_arguments >
   
2. class list_inserter
   
3. {
   
4.         list_inserter( Function fun ) : insert_( fun )
   
5.         {}
   
6.         
   
7.         ....
   
8.         
   
9.         list_inserter& operator()()
   
10.         {
    
11.                 insert_( Argument() );
    
12.                 return *this;
    
13.         }
    
14.         
    
15.         template< class T >
    
16.         list_inserter& operator,( const T& r )
    
17.         {
    
18.                 insert_( r );
    
19.                 return *this;
    
20.         }
    
21.         
    
22.         private: Function insert_;
    
23. }

复制代码

这里的insert_就是先前的assign_detail::call_push_back ( c )，所以insert_( r )就是 assign_detail::call_push_back ( c )( r )。
list_inserter还有repeat,repeat_fun,range等方法，分别对应assign中 i_v+=1,repeat(2,4),3....等写法的实现。针对vector的assign基本就是这样，至于map等其它容器的assign,实现与此类似。