boost::mpl::vector(MSVC)源码分析

代码看起来很直接，没有前面宏定义那么复杂。但头文件的相互包括比较复杂。
如果仅仅是利用VS助手来寻找代码，出错的可能性非常之大。
对于模板元的调试非常的特殊。正确的代码是不能调试的，而是故意把它写错:比如，
vector1只能存放一个元素，那么故意写成两个元素，超出了界限，编译器自然会报错。
这样可以知道编译器调用的是什么地方的代码了。否则调用的是什么地方的代码都不知道（花了大量的时间来寻找代码）。
有些模板仅仅是声明没有定义。这样只是起一个标记作用，用类型来标记。这个vector同那个vector是不同的。比如：vector_tag<1>和vector_tag<2>就是不同，他们代表不同的类型。它的差异仅仅用类型就可以做到。网上仅有一篇博客说是定义，这儿显然是不对。如果是定义可以生成对像，我试了aux::vector_tag不能生成对像。
// Copyright Aleksey Gurtovoy 2000-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Preprocessed version of "boost/mpl/vector/vector10.hpp" header
// -- DO NOT modify by hand!
#   define BOOST_MPL_AUX_NTTP_DECL(T, x) T x /**/
struct v_iter_tag;//仅仅是一个标志
struct integral_c_tag { BOOST_STATIC_CONSTANT(int, value = 0); };
template< int  N>
struct int_
{
    enum { value = N };
    typedef  int   type;
    typedef  int_  value_type;
    typedef integral_c_tag tag;
    typedef int_<value+1> next;
    typedef int_<value-1> prior;
    // enables uniform function call syntax for families of overloaded
    // functions that return objects of both arithmetic ('int', 'long',
    // 'double', etc.) and wrapped integral types (for an example, see
    // "mpl/example/power.cpp")
    operator int() const { return static_cast<int>(this->value); }
};
namespace boost { namespace mpl {
//起标记作用。同STL的代码这点来说很相似。
    struct forward_iterator_tag       : int_<0> { typedef forward_iterator_tag type; };
    struct bidirectional_iterator_tag : int_<1> { typedef bidirectional_iterator_tag type; };
    struct random_access_iterator_tag : int_<2> { typedef random_access_iterator_tag type; };
}}
#   define BOOST_MPL_AUX_COMMON_NAME_WKND(name) /**/
#define BOOST_MPL_AUX_NA_PARAM(param) param = na
namespace boost { namespace mpl {
        BOOST_MPL_AUX_COMMON_NAME_WKND(next)
        BOOST_MPL_AUX_COMMON_NAME_WKND(prior)
        template<
        typename BOOST_MPL_AUX_NA_PARAM(T)// typename T = na
        >
        struct next
        {
            typedef typename T::next type;
            BOOST_MPL_AUX_LAMBDA_SUPPORT(1,next,(T))
        };
        template<
            typename BOOST_MPL_AUX_NA_PARAM(T)
        >
        struct prior
        {
            typedef typename T::prior type;
            BOOST_MPL_AUX_LAMBDA_SUPPORT(1,prior,(T))
        };
        BOOST_MPL_AUX_NA_SPEC(1, next)
        BOOST_MPL_AUX_NA_SPEC(1, prior)
}}
namespace boost { namespace mpl {
    //#   define BOOST_MPL_AUX_NTTP_DECL(T, x) T x /**/
    template<
        typename Vector
        ,long n_
    >
    struct v_iter
    {
        typedef aux::v_iter_tag tag; //标记
        typedef random_access_iterator_tag category;//迭代器类型
        typedef typename v_at<Vector,n_>::type type;//这是在vector中特化的版本。
        typedef Vector vector_;
        typedef mpl::long_<n_> pos;
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
        enum {
            next_ = n_ + 1
            , prior_ = n_ - 1
            , pos_ = n_
        };
        typedef v_iter<Vector,next_> next; //实际上重新生成一个v_iter
        typedef v_iter<Vector,prior_> prior;
#endif
    };
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
    template<
        typename Vector
        , BOOST_MPL_AUX_NTTP_DECL(long, n_)//long n_
    >
    struct next< v_iter<Vector,n_> >//这儿来看，显然不主模版。因为这儿只有一个参数v_iter,是一个特化版本。
    {
        typedef v_iter<Vector,(n_ + 1)> type;//重新生成一个v_iter
    };
    template<
        typename Vector
        , BOOST_MPL_AUX_NTTP_DECL(long, n_)
    >
    struct prior< v_iter<Vector,n_> >//同上面一样。
    {
        typedef v_iter<Vector,(n_ - 1)> type;//重新生成一个v_iter
    };
#   define BOOST_MPL_AUX_NESTED_VALUE_WKND(T, C) /
    BOOST_MPL_AUX_VALUE_WKND(C)::value /
    /**/
    #   define BOOST_MPL_AUX_VALUE_WKND(C) C
#endif
}}
#endif // BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED
namespace boost { namespace mpl {
    //特化版本，在其他地方声明
    template< typename V >
    struct v_at< V,0 >
    {
        typedef typename V::item0 type;//V代表的是vector,item0就是第一个元素值。
    };
    template<
        typename T0
    >
    struct vector1
    {  //这仅是一个标记，只对它进行了声明，没有对它进行定义。代表一个特定的类型。
        typedef aux::vector_tag<1> tag;
        typedef vector1 type;
        typedef T0 item0;//vector1存放的元素T0
        typedef void_ item1;//
        typedef T0 back;
        typedef v_iter< type,0 > begin; //
        typedef v_iter< type,1 > end;
    };
    template<>
    struct push_front_impl< aux::vector_tag<0> >
    {
        template< typename Vector, typename T > struct apply
        {
            typedef vector1<//只有一个元素，重新生成一个vector1即可。
                T
            > type;
        };
    };
    template<>
    struct pop_front_impl< aux::vector_tag<1> >
    {
        template< typename Vector > struct apply
        {
            typedef vector0<  //对于vector1来说，pop出一个元素之后，就没有任何元素了。
            > type;
        };
    };
    template<&g