而在TCPL的题解里面提到了输入参数是向前迭代器的情况（Forward iterator）。这样reverse算法得重新设计。
算法概述：
    1.反转一个向前序列，可以首先将序列分成大致一样长的两半。然后用std::swap_ranges算法交换着两个半长序列。
    2.递归地反转这个两个半长序列。
[注意一下序列元素的个数（奇偶数）]
template<typename For>
void forward_reverse(For begin1, int len)
{
 if(len > 1){
  int half_len = len / 2;
  For end1 = begin1;
  advance(end1, hal_len);
  For begin2 = end1;
  if(len % 2 != 0) //序列个数为奇数
   ++begin2;

  std::swap_ranges(begin1, end1, begin2);
  forward_reverse(begin1, half_len);
  forward_reverse(begin2, half_len);
 }
}

再为forward_reverse函数和reverse（bidirection）函数提供一个统一的借口。
template<typename It>
inline void flex_reverse(It begin, It end)
{
 using std::iterator_traits;
 tagged_reverse(begin, end, iterator_traits<It>::iterator_category());
}

tagged_reverse()函数是通过函数重载和迭代器特征类（萃取技术）的结合来完成下面两个函数的自动选择。

template<typename For>  //forward_reverse封装
inline void tagged_reverse(For begin, For end, std::forward_iterator_tag)
{
 forward_reverse(begin, distance(begin, end));
}

template<typename For>  //reverse封装
inline void tagged_reverse(For begin, For end, std::bidirectional_iterator_tag)
{
 reverse(begin, end);
}

后来我发现好像把Forward_iterator的容器并不多见。
STL容器：1、双向迭代器（Bidirectional iterator）
            list、set、multiset、map、multimap
        2、随机存取迭代器（Random access iterator）
            vector、deque、string

附：iterator_traits模板类中的一组声明描述：
template<class Iter> struct iterator_traits
{
 typedef typename Iter::iterator_category iterator_category;
 typedef typename Iter::value_type value_type;
 typedef typename Iter::difference_type difference_type;
 typedef typename Iter::pointer pointer;
 typedef typename Iter::reference reference;
};

有时候，我们会犯这样的错误，把两个不同序列的迭代器去构成一个序列了。比如：

这里Bjarne Stroustrup给出一个解决问题的途径。其关键就是用整个容器代替x.begin, x.end()的输入。
这样，我们要封装两个东西，1、find()函数。 2、begin(),end()

利用重载，封装find函数。

利用对偶，封装迭代器。
首先，我们构造一个Iseq以保证迭代器是统一序列成对输入的。

接着构造一个协助函数，直接传递容器。

这样，我们可以利用上面的机制，来避免所提出的错误。

下面我们仔细分析整个机制的几个细节。
先让我们来看看pair的样子。

template < class  T1,  class  T2 > struct  std::pair{  // 这里用struct来定义
    typedef T1 first_type;
    typedef T2 second_type;

    T1 first;
    T2 second;

    pair(): first(T1()), second(T2()){}
    pair( const  T1 &  x,  const  T2 &  y): first(x), second(y){}
    template < class  U,  class  v >
        pair( const  pair < U, V >&  p): first(p.first), second(p.second){}
     //
};

注意pair的两个数据成员first, second都是public的，所以Iseq继承pair之后可以直接访问。

考察find()函数的重载版本
find(Iseq<In> r, const T& v)
注意“Iseq<In> r”使用值传递，而不用引用传递（Iseq<In>& r）。
这是因为iiseq协助函数返回一个临时对象，所以在find中，不能用引用传递。
template<class C>Iseq<typename C::iterator> iiseq(C& c) //C为容器
{
 return Iseq<typename C::iterator>(c.begin(), c.end());
}
大家可能会考虑到效率问题，觉得值传递可能不妥。其实不然，我们可以发现，Iseq里面的数据成员是两个Iterator，一般来说不是很大（有时，就是两个指针），在效率上不会产生很大的影响。

还有这里代码中出现typename,(如return Iseq<typename C::iterator>(c.begin(), c.end());) 可能对初学者来说有些生疏。为什么不直接写： Iseq<C::iterator>(c.begin(), c.end())。这是由于编译器不能直接认出C::iterator是一种类型，所以我们加上修饰符号typename告诉编译器C::iterator使用一种类型。