在看 《c++ 模板元编程》 的过程中，我时时刻刻都会有新发现。对于这之前从未接触过 Boost 库的我来说，惊奇的感觉尤甚。初看此书的习题4-5：哈，不就是实现一个 param_type 嘛。的确是，不过 answer 页上的测试代码，才是让我惊奇的东西：

using namespace boost::assign;
std::vector<int> v1;
v1 += 1, 2, 30, 40, 500;

   话不多讲，按图索骥的来分析。既然是 vector 的操作，那就找出对应的头文件来看看。第一句使用了 boost::assign 命名空间，而 STL 库中当然不会提供这样的 operator+= ，果然在 boost\assign\std\vector.hpp 中有声明：

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 );
}

    For the god’s sake ，它一口气抛给我这么多待查的东西，这不是打击我的求知欲么！（歇息片刻……）继续。先不管这个重载操作符的返回值，待会在函数的返回语句中自然会了解到。看到 push_back( c )( v ) 这个句子，当然是一个 operator()，继续搜索。这一次，VS 代码查看工具直接把我带到了目的地—— boost\assign\list_inserter.hpp 这块新大陆。接下来的一切都将在这里发生。首先我到了 “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;//static typename std::vector<int>::value_type* p = 0;
    return make_list_inserter( assign_detail::call_push_back<C>( c ), p );
}

    为了方便查看，把 make_list_inserter 和 call_push_back 也列出来：

template< class Function, class Argument >
inline list_inserter<Function,Argument>
make_list_inserter( Function fun, Argument* ) {
    return list_inserter<Function, Argument>( fun );
}

template< class C >
class call_push_back {
    C& c_;  //这里，c_ 是 vector<int>& v1
public:
    call_push_back( C& c ) : c_( c ) { }
    
    template< class T >
    void operator()( T r ) {
        c_.push_back( r );
    }
};

    过了这条流水线，现在 operator+= 中的 push_back( c ) 就被加工成了：

    list_inserter<call_push_back, p>( call_push_back<vector<int> > ) ，其私有成员 insert_ 为 call_push_back<vector<int> > 。前面提到的 operator() 就要登场了，先看 list_inserter 的部分代码：

template< class Function, class Argument = assign_detail::forward_n_arguments > 
class list_inserter {
    ...  
public:
    list_inserter( Function fun ) : insert_( fun ) {}    
    ...

    list_inserter& operator()() {    //这就是那个 operator() ! 终于找到你了
        insert_( Argument() );
        return *this;
    }
    ...    
    template< class T >
    list_inserter& operator,( const T& r ) { //它化腐朽为神奇，逗号(,)从以前的“路标”升级成了“交警”

        insert_( r  );
        return *this;
    }

    ... ...

private:   
    list_inserter& operator=( const list_inserter& );
    Function insert_;  // call_push_back

};

    到这里，第一个 v1 += 1 就是下面这个样子：

    list_inserter<call_push_back, p>( call_push_back<vector<int> > )( 1 )

    相当于 call_push_back(1)，call_push_back的 c_ 成员就是 v1 的引用，就相当于 v1.push_back(1) 。第一个元素进入了容器，鼓掌。

    看过代码后，逗号（ , ）就不足为奇了， v1 += 1, 2, 30, 40, 500; 句子中的 “,”， 功能是依次插入逗号后的元素。

    继续探索新大陆……