function object研究之十五 list1分析
首先看一下bind.hpp中的list0模板定义：
class list0
{
public:
list0() {}
template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
{
return unwrapper<F>::unwrap(f, 0)();
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
{
return unwrapper<F const>::unwrap(f, 0)();
}
template<class F, class A> void operator()(type<void>, F & f, A &, int)
{
unwrapper<F>::unwrap(f, 0)();
}
template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
{
unwrapper<F const>::unwrap(f, 0)();
}
template<class V> void accept(V &) const
{
}
bool operator==(list0 const &) const
{
return true;
}
};
提供了accept方法接受V&,但是什么实现也没有。提供了一堆operator重载函数，重点关注operator()()的函数，说明其实list0就是一个function object。
1.type<R>是什么？定义如下：
template<class T> class type {};只是一个普通模板，接受任何类型。
2.unwrap(f,0)的结果是返回f, 因此如果f是以一个函数传递给了operator()(type<R>, F& f, A&, long) ，则内部的unwrap(f,0)返回的是f
因此实际上代码被编译成了直接调用f的代码：f()
这是个很好的让编译器在编译期产生调用函数代码的技巧。
unwrap还接受另外两种类型，参考：http://blog.csdn.net/sheismylife/article/details/8272615
因此功能比较强大。
3.实际上f函数执行的时候传递进来的参数这里是空，下面就能看到有一个参数的例子。
继续看list1的定义：
template< class A1 > class list1: private storage1< A1 >
{
private:
typedef storage1< A1 > base_type;
public:
explicit list1( A1 a1 ): base_type( a1 ) {}
A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
{
return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
}
template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
{
return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
}
template<class F, class A> void operator()(type<void>, F & f, A & a, int)
{
unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
}
template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
{
unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
}
template<class V> void accept(V & v) const
{
base_type::accept(v);
}
bool operator==(list1 const & rhs) const
{
return ref_compare(base_type::a1_, rhs.a1_, 0);
}
};看到很多老朋友了吧？
1.从storage1<A1>继承，回顾前面的文章：http://blog.csdn.net/sheismylife/article/details/8269153
因此也就拥有了a1_, 这里有点不明白，为什么偏特化版本的storag1没有定义a1_，只有a1()静态函数，居然这里就有了。下面的代码编译通过。
boost::_bi::storage1<boost::arg<1> > x(_1);
x.a1_;
2. 几个operator[]() 函数有点意思，用_1作为下标，调用的是第一个重载：
list[_1];
-->
A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
3.operator()()函数的参数A & a实际上也是一个list1<A1 &>对象，并且里面的a_成员就是外部实际调用的参数。
a[base_type::a1_] 这句代码要注意：
通过this对象的base_type::a1_，这时候a1_是指针函数，返回占位符boost::arg<1> 。
用a1_来作为参数，传递给a对象的operator[](boost::arg<1> (*)() 方法来获取内部保存的实际参数。
a对象和this对象都是一个从模板list1<>演化而来，但是不是同一个对象。
4.其他的函数都比较简单, accept以前也介绍过，visitor模式的实现。