分析源码其实很有意思，尤其是优秀的源码。boost::assign库，老实说，设计初衷有些无聊，它无非是想让容器的赋值（插入）操作更加简单，简单得就像脚本语言一样，比如，原来的STL里的容器有各种各样的，不同的容器会有不同的赋值方式，比如： #include<vector>using namespace std:int main(){ vector<int> v; v.push_back(1); v.push_back(2); v.push_back(3); return 0;} 如果你不觉得敲‘.push_back’多么麻烦，大可不必管这个库，实际上这样写，机器看起来更简单。而boost就想办法让人偷懒，而机器转一些弯，成了这样： int main(){ vector<int> v; v+=1,2,3; return 0;} 能够运行的示范代码我没有找到啊，只是写个样子出来，OMG，真像脚本语言！你要问，效率如何？可能会牺牲一些，就像，我问你，仿函数比函数的调用效率是不是低一些，如果是，那STL里还不是大量用仿函数？但这些差别，绝对不是相差很大，不会有质的差别。 好了，下面进行分析，我不是设计者，不知道大哥他是怎么想的，我只从分析的角度说明。 1，设计各种仿函数来管理具体的容器和它的赋值方法 仿函数比函数好的一个地方，它可以有成员变量，而这里就关联了这个具体的容器。在源码的assign/list_inserter.hpp里的前面部分，有一个namespace assign_detail命名空间，在那里定义了各种，仿函数，比如调用push_back的 template< class C > class call_push_back { C& c_; public: call_push_back( C& c ) : c_( c ) { } template< class T > void operator()( T r ) { c_.push_back( r ); } }; 调用insert的 template< class C > class call_insert { C& c_; public: call_insert( C& c ) : c_( c ) { } template< class T > void operator()( T r ) { c_.insert( r ); } }; 那个大C表示容器Container，看到成员c了没有，在那里关联了外面的具体容器，它是一个引用，所以没有进行低效的复制操作，只是一个关联。operator()是调用函数，它简单的指向不同容器的具体赋值操作。 2，重载各种符号运算 再下来，外面是一个封装，类list_inserter，它是一个核心类，它关联一个具体的赋值仿函数对象，同时，重载了一些简单的操作符，比如operator, operator()等。一但成功建立了一个list_inserter，后面的赋值就可以用一些简单的符号进行了。它的样子是这样的： template< class Function, class Argument = assign_detail::forward_n_arguments > class list_inserter { ... private: list_inserter& operator=( const list_inserter& ); Function insert_; } 它关联一个赋值仿函数对象，具体的操作由它来完成，然后你会看到，各种各样的操作，比如operator,都是用insert_()来完成的，那个拷贝函数设成私有，就是用来禁止拷贝的，如果用户拷贝会有一个权限错误，不能访问私有成员，如果类本身访问，会有一个连接错误，总之是不能拷贝，当然那个insert_也不能，同样，具体的容器也就没有拷贝。 list_inserter是怎么建立起来的，它需要一些外部的函数来完成，这些函数是和具体的容器相关的，所以需要为每种容器写一份，在assign/std/目录里就是各种这样的定义，如vector.hpp里有简单这样几行： namespace boost{namespace assign{ template< class V, class A, class V2 > inline list_inserter< assign_detail::call_push_back< std::vector<V,A> >, V > operator+=( std::vector<V,A>& c, V2 v ) { return push_back( c )( v ); } }} （只例关键的），那是一个重载的operator+=，左边是一个V类型A分配器的vector，右边是一个V2类型的值，它具体是由push_back函数完成，你看到它这样写push_back(c)(v)，实际上是先调用了push_back(c)，它返回了一个list_inserter，再后面的(v)，是将v插入进去，看push_back()定义： template< class C > inline list_inserter< assign_detail::call_push_back<C>, BOOST_DEDUCED_TYPENAME C::value_type > push_back( C& c ) { static BOOST_DEDUCED_TYPENAME C::value_type* p = 0; return make_list_inserter( assign_detail::call_push_back<C>( c ), p ); } 它果然返回的是一个list_inserter，插入仿函数是call_push_back，每二个参数是容器元素类型，每个容器内都要定义一个value_type，那个BOOST_DEDUCED_TYPENAME我猜就是typename，说明一个内嵌类型，那个static定义，也没有为多次调用push_back带来任何负担，再转调用make_list_inserter()，看它的定义： template< class Function, class Argument > inline list_inserter<Function,Argument> make_list_inserter( Function fun, Argument* ) { return list_inserter<Function,Argument>( fun ); } 它有两个形式，这只是其中一个，有元素类型的定义，那个传进来的Argument* p没有任何用，只是做一个类型推导，用仿函数对象fun初始化list_inserter，看到这里没有引用返回，list_inserter只是不能拷贝，但是可以拷贝构造。所以push_back( c )最终得到的、具现出的结果是：list_inserter<assign_detail::call_push_back<vector<int>>,int>( assign_detail::call_push_back<vector<int>>(v) ) 再调用list_inserter的operator()，它转调用的是insert_()，即用assign_detail::call_push_back<vector<int>>的operator()将初值插入到了容器。 总的看一下list_inserter支持多少种操作符重载（下面都是list_inserter的成员函数）： list_inserter& operator()() { insert_( Argument() ); return *this; } template< class T > list_inserter& operator=( const T& r ) { insert_( r ); return *this; } template< class T > list_inserter& operator=( assign_detail::repeater<T> r ) { return operator,( r ); } template< class Nullary_function > list_inserter& operator=( const assign_detail::fun_repeater<Nullary_function>& r ) { return operator,( r ); } template< class T > list_inserter& operator,( const T& r ) { insert_( r ); return *this; } template< class T > list_inserter& operator,( const assign_detail::repeater<T> & r ) { return repeat( r.sz, r.val ); } template< class Nullary_function > list_inserter& operator,( const assign_detail::fun_repeater<Nullary_function>& r ) { return repeat_fun( r.sz, r.val ); } template< class T > list_inserter& repeat( std::size_t sz, T r ) { std::size_t i = 0; while( i++ != sz ) insert_( r ); return *this; } template< class Nullary_function > list_inserter& repeat_fun( std::size_t sz, Nullary_function fun ) { std::size_t i = 0; while( i++ != sz ) insert_( fun() ); return *this; } template< class SinglePassIterator > list_inserter& range( SinglePassIterator first, SinglePassIterator last ) { for( ; first != last; ++first ) insert_( *first ); return *this; } template< class SinglePassRange > list_inserter& range( const SinglePassRange& r ) { return range( boost::begin(r), boost::end(r) ); } template< class T > list_inserter& operator()( const T& t ) { insert_( t ); return *this; } 主要是operator,，它完成插入，还有operator()(T&)，另外operator()()是插入一个临时元素，相当于空一位，此外还有几个帮助函数，assign_detail::repeater<T>和assign_detail::fun_repeater<Fun>，它们的作用很简单，可以帮助插入多个相同元素，或用一个函数构造多个元素，我们可以使用namespace assign里的repeat和repeat_fun来完成。 另外，还有一个mpl里的东西，那个if_c，其实可以找到他的定义，因为mpl库很大，不好说太多，那句是这样的： typedef BOOST_DEDUCED_TYPENAME mpl::if_c< is_same<Argument,assign_detail::forward_n_arguments>::value, n_arg_type, single_arg_type >::type arg_type; is_same<>是type_traits库里的，用来测试那两个类型是否相同，如果相同value==true，否则value==false，而if_c里定义的type，对第一个参数有特化版，如果true则type==第二个参数，否则type==第三个参数，它就像我们以前的if-else一样，只不过是在编译期做的判断。 最后，马上要过年啦，2008新春快乐！ rickone 2008/2/5
评论