STL适配器（adapters）

• Insert Iterator：将容器绑定到back_insert_iterator、front_insert_iterator、insert_iterator。它们都是一个类，对它们的赋值操作将转换为对绑定容器的插入操作。为了操作方便，向用户提供的是一个函数，函数中才创建上述类。

template <class Container>
inline back_insert_iterator<Container> back_inserter(Container& x) {
  return back_insert_iterator<Container>(x);     // 以容器为参数，创建迭代器适配器
}

template <class Container>
class back_insert_iterator {
protected:
  Container* container; // 注意，这里是一个指向容器的指针
public:
  typedef output_iterator_tag iterator_category;     // 输出迭代器，只支持自增
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;
 
  explicit back_insert_iterator(Container& x) : container(&x) {}     // 与容器相绑定
  back_insert_iterator<Container>&
  operator=(const typename Container::value_type& value) { 
    container->push_back(value);
    return *this;
  }
  back_insert_iterator<Container>& operator*() { return *this; }
  back_insert_iterator<Container>& operator++() { return *this; }
  back_insert_iterator<Container>& operator++(int) { return *this; }
};

#include <iostream>
#include <vector>
 
using namespace std;
 
template <class Container>
class my_back_insert_iterator {
protected:
  Container* container;
public:
  explicit my_back_insert_iterator(Container& x) : container(&x) {}
  my_back_insert_iterator<Container>&
  operator=(const typename Container::value_type& value) {
    container->push_back(value);
    return *this;
  }
};
 
int main()
{
    vector<int> vec;
    my_back_insert_iterator< vector<int> > back_insert(vec);
 
    back_insert = 1;
    back_insert = 2;
    back_insert = 3;
    back_insert = 4;
 
    vector<int>::iterator iter = vec.begin();
    for ( ; iter != vec.end(); ++iter)
        cout << *iter << endl;
 
    return 0;
}

template <class T>
class ostream_iterator {
protected:
  ostream* stream;     // 绑定的标准输出
  const char* string;  // 分隔符
public:
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;
 
  ostream_iterator(ostream& s) : stream(&s), string(0) {}
  ostream_iterator(ostream& s, const char* c) : stream(&s), string(c)  {}
  ostream_iterator<T>& operator=(const T& value) { 
    *stream << value;               // 关键点
    if (string) *stream << string;  // 输出间隔符
    return *this;
  }
// 以下三个操作都返回自己
  ostream_iterator<T>& operator*() { return *this; }
  ostream_iterator<T>& operator++() { return *this; } 
  ostream_iterator<T>& operator++(int) { return *this; } 
};

• 绑定器（bind1st/bind2nd）：将一个操作数绑定到给定值而将二元函数对象转换为一元函数对象。
• 求反器：将谓词函数对象的真值求反。

// 计算容器中小于等于3的元素个数
cout << count_if(vec.begin(), vec.end(), bind2nd(less_equal<int>(), 3));

template <class InputIterator, class Predicate, class Size>
void count_if(InputIterator first, InputIterator last, Predicate pred,
              Size& n) {
  for ( ; first != last; ++first)
    if (pred(*first))       /* 对每个元素调用仿函数 */
      ++n;                  /* 满足条件则累加 */
}

template <class Operation> 
class binder2nd
  : public unary_function<typename Operation::first_argument_type,
                          typename Operation::result_type> {
protected:
  Operation op;
  typename Operation::second_argument_type value;
public:
  binder2nd(const Operation& x,   // 仿函数
            const typename Operation::second_argument_type& y)  // 绑定的第二个数
      : op(x), value(y) {}
  typename Operation::result_type
  operator()(const typename Operation::first_argument_type& x) const {
    return op(x, value);  // 关键点
  }
};