STL学习_配接器篇

  • 定义

    配接器（Adapter）在STL组件的灵活组合运用功能上，扮演着轴承、转换器的角色。它事实上是一种设计模式。即将一个class的接口转换为另一个class的接口，使原本因接口不兼容而不能合作的classes，可以一起运作。

  • 分类

    STL所提供的各种适配器中，改变仿函数（functors）接口者，称为function adapter；改变容器（containers）接口者，称为container adapter；改变迭代器（iterators）接口者，称为iterator adapter。

    functor adapters

    functor adapters是所有配接器中数量最庞大的一个族群，其配接灵活度是后两者不能及的，可以配接、配接、在配接。其中配接操作包括系结（bind）、否定（negate）、组合（compose）、以及对一般函数或成员函数的修饰（使其成为一个仿函数）。它的价值在于，通过它们之间的绑定、组合、修饰能力，几乎可以无限制地创造出各种可能的表达式（expression），搭配STL算法一起演出。

    由于仿函数就是“将function call操作符重载”的一种class，而任何算法接受一个仿函数时，总是在其演算过程中调用该仿函数的operator()，这使得不具备仿函数之形、却有真函数之实的“一般函数”和“成员函数（member functions）感到为难。如果”一般函数“和“成员函数”不能纳入复用的体系中，则STL的规划将崩落了一角。为此，STL提供了为数众多的配接器，使“一般函数”和“成员函数”得以无缝地与其他配接器或算法结合起来。

    注意，所有期望获取配接能力的组件，本身都必须是可配接的，即一元仿函数必须继承自unary_function，二元仿函数必须继承自binary_function，成员函数必须以mem_fun处理过，一般函数必须以ptr_fun处理过。一个未经ptr_fun处理过的一般函数，虽然也可以函数指针的形式传给STL算法使用，却无法拥有任何配接能力。

    container adapters

    STL提供了两个容器queue和stack，其实都只不过是一种配接器。它们修饰deque的接口而成就出另一种风貌。queue和stack底层都是由deque构成的，它们封住所有deque对外接口，只开发符合对应原则的几个函数，故它们是适配器，是一个作用于容器之上的适配器。

    iterator adapters

    STL提供了许多应用于迭代器身上的配接器，包括insert iterators，reverse iterators，iostream iterators。insert iterators可以将一般迭代器的赋值（assign）操作转变为插入（insert）操作。此迭代器包括专门从尾端插入操作back_insert_iterator，专门从头端插入操作front_insert_iterator，以及可从任何位置执行插入操作的insert_iterator。因iterator adapters使用接口不是十分直观，STL提供三个相应的函数back_inserter()、front_inserter()、inserter()，从而提高使用时的便利性。reverse iterators可以将一般迭代器的行进方向逆转，使原本应该前进的operator++变成了后退操作，使原本应该后退的operator–变成了前进操作。此操作用在“从尾端开始进行”的算法上，有很大的方便性。iostream\ iterators可以将迭代器绑定到某个iostream对象身上。绑定到istream对象身上，为istream_iterator，拥有输入功能；绑定到ostream对象身上，成为ostream_iterator，拥有输出功能。此迭代器用在屏幕输出上，非常方便。

  • 源码分析

    1）insert iterator

    // iterator adapter迭代器配接器，用来将某个迭代器的赋值（assign）操作
// 修改为插入（insert）操作——从容器的尾端插入进去，故称为back_insert
template <class _Container>
class back_insert_iterator {
protected:
  _Container* container;     // 底部容器
public:
  typedef _Container          container_type;      // 注意类型
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;
  // 使用back_insert_iterator与容器绑定起来
  explicit back_insert_iterator(_Container& __x) : container(&__x) {}
  back_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) { 
    container->push_back(__value);    // 关键，转而调用push_back()
    return *this;
  }
  // 以下三个操作符对back_insert_iterator不起作用（关闭功能）
  // 三个操作符返回的都是back_insert_iterator自己
  back_insert_iterator<_Container>& operator*() { return *this; }
  back_insert_iterator<_Container>& operator++() { return *this; }
  back_insert_iterator<_Container>& operator++(int) { return *this; }
};
// 辅助函数，便于使用back_insert_iterator 
template <class _Container>
inline back_insert_iterator<_Container> back_inserter(_Container& __x) {
  return back_insert_iterator<_Container>(__x);

// 这是一个迭代器配接器（iterator adapter），用来将某个迭代器的赋值（assign）操作修改为插入（insert）
// 操作——从容器的头端插入进去（称为front_insert）
// 注意，该迭代器不适用于vector，因为vector都没提供push_front函数
template <class _Container>
class front_insert_iterator {
protected:
  _Container* container;   // 底层容器
public:
  typedef _Container          container_type;       // 注意类型
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  explicit front_insert_iterator(_Container& __x) : container(&__x) {}
  front_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) { 
    container->push_front(__value);    // 此处为关键，转而调用push_front()
    return *this;
  }
  // 以下三个操作符对front_insert_iterator不起作用（关闭功能）
  // 三个操作符返回的都是front_insert_iterator自己
  front_insert_iterator<_Container>& operator*() { return *this; }
  front_insert_iterator<_Container>& operator++() { return *this; }
  front_insert_iterator<_Container>& operator++(int) { return *this; }
};
// 辅助函数，便于使用front_insert_iterator
template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) {
  return front_insert_iterator<_Container>(__x);
}

// 这是一个迭代器适配器（iterator adapter），用来将某个迭代器的赋值assign操作修改为插入（insert）
// 操作，在指定的位置上进行，并将迭代器右移一个位置——如此便可很方便地连续执行“表面上是赋值（覆写）
// 而实际上是插入”的操作。
template <class _Container>
class insert_iterator {
protected:
  _Container* container;     // 底层容器
  typename _Container::iterator iter;
public:
  typedef _Container          container_type;      // 注意类型
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i) 
    : container(&__x), iter(__i) {}
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) { 
    iter = container->insert(iter, __value);   // 此处为关键，转调用insert()函数
    ++iter;      // 注意此处，使insert_iterator永远随其目标贴身移动
    return *this;
  }
  // 以下三个操作符对insert_iterator不起作用（关闭功能）
  // 三个操作符返回的都是insert_iterator自己
  insert_iterator<_Container>& operator*() { return *this; }
  insert_iterator<_Container>& operator++() { return *this; }
  insert_iterator<_Container>& operator++(int) { return *this; }
};
// 辅助函数，便于使用insert_iterator
template <class _Container, class _Iterator>
inline 
insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)
{
  typedef typename _Container::iterator __iter;
  return insert_iterator<_Container>(__x, __iter(__i));
}

    2）reverse iterator

    // 迭代器配接器（iterator adapter），用来将某个迭代器逆反前进方向，使前进为后退，后退为前进
class reverse_iterator {
  typedef reverse_iterator<_RandomAccessIterator, _Tp, _Reference, _Distance>
        _Self;     // 代表逆向迭代器  
protected:
  _RandomAccessIterator current;    // 记录对应之正向迭代器
public:
  // 逆向迭代器的5种相应型别（associated types）都和其对应的正向迭代器相同
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                        value_type;
  typedef _Distance                  difference_type;
  typedef _Tp*                       pointer;
  typedef _Reference                 reference;

  reverse_iterator() {}
  // 将reverse_iterator与某个迭代器x系结起来
  explicit reverse_iterator(_RandomAccessIterator __x) : current(__x) {}
  _RandomAccessIterator base() const { return current; }   // 取出对应的正向迭代器
  _Reference operator*() const { return *(current - 1); }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  // 前进（++）变成后退（--）
  _Self& operator++() {
    --current;
    return *this;
  }
  _Self operator++(int) {
    _Self __tmp = *this;
    --current;
    return __tmp;
  }
  // 后退（--）变成前进（++）
  _Self& operator--() {
    ++current;
    return *this;
  }
  _Self operator--(int) {
    _Self __tmp = *this;
    ++current;
    return __tmp;
  }
  // 前进与后退完全逆转
  _Self operator+(_Distance __n) const {
    return _Self(current - __n);
  }
  _Self& operator+=(_Distance __n) {
    current -= __n;
    return *this;
  }
  _Self operator-(_Distance __n) const {
    return _Self(current + __n);
  }
  _Self& operator-=(_Distance __n) {
    current += __n;
    return *this;
  }
  // 注意：下面第一个*和唯一一个+都会调用本类的operator*和operator+
  // 第二个*则不会（判断法则：完全看处理的型别而定）
  _Reference operator[](_Distance __n) const { return *(*this + __n); }
};

    3）stream iterators

    // input iterator，能够为“来自某一basic_istream”的对象执行格式化输入操作
template <class _Tp, class _Dist>
class istream_iterator {
#ifdef __STL_TEMPLATE_FRIENDS
  template <class _T1, class _D1>
  friend bool operator==(const istream_iterator<_T1, _D1>&,
                         const istream_iterator<_T1, _D1>&);
#else /* __STL_TEMPLATE_FRIENDS */
  friend bool __STD_QUALIFIER
  operator== __STL_NULL_TMPL_ARGS (const istream_iterator&,
                                   const istream_iterator&);
#endif /* __STL_TEMPLATE_FRIENDS */

protected:
  istream* _M_stream;
  _Tp _M_value;
  bool _M_end_marker;
  void _M_read() {
    _M_end_marker = (*_M_stream) ? true : false;
    if (_M_end_marker) *_M_stream >> _M_value;      // 关键
    // 以上，输入之后，stream的状态可变，所以下面再判断一次以决定end_marker
    // 当读到eof或读到型别不符的资料，stream即处于false状态
    _M_end_marker = (*_M_stream) ? true : false;
  }
public:
  typedef input_iterator_tag  iterator_category;
  typedef _Tp                 value_type;
  typedef _Dist               difference_type;
  typedef const _Tp*          pointer;
  typedef const _Tp&          reference;
  // 以上，因身为input iterator，所以采用const比较保险
  istream_iterator() : _M_stream(&cin), _M_end_marker(false) {}
  istream_iterator(istream& __s) : _M_stream(&__s) { _M_read(); }
  reference operator*() const { return _M_value; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  // 迭代器前进一个位置，就代表要读取一批数据
  istream_iterator<_Tp, _Dist>& operator++() { 
    _M_read(); 
    return *this;
  }
  istream_iterator<_Tp, _Dist> operator++(int)  {
    istream_iterator<_Tp, _Dist> __tmp = *this;
    _M_read();
    return __tmp;
  }
};

// output iterator，能够将对象格式化输出到某个basic_ostream上
template <class _Tp>
class ostream_iterator {
protected:
  ostream* _M_stream;       
  const char* _M_string;   // 每次输出后的间隔符号，变量名称为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) : _M_stream(&__s), _M_string(0) {}
  ostream_iterator(ostream& __s, const char* __c) 
    : _M_stream(&__s), _M_string(__c)  {}
  // 对迭代器做赋值（assign）操作，就代表要输出一批数据
  ostream_iterator<_Tp>& operator=(const _Tp& __value) { 
    *_M_stream << __value;                   // 关键：输出数值
    if (_M_string) *_M_stream << _M_string;  // 如果间隔符号不为空，输出间隔符号
    return *this;
  }
  // 注意以下三个操作
  ostream_iterator<_Tp>& operator*() { return *this; }
  ostream_iterator<_Tp>& operator++() { return *this; } 
  ostream_iterator<_Tp>& operator++(int) { return *this; } 
};

    4）function adapters

    • 对返回值进行逻辑否定：not1，not2

      // 以下配接器用来表示某个Adaptable Predicate的逻辑负值
template <class _Predicate>
class unary_negate
  : public unary_function<typename _Predicate::argument_type, bool> {
protected:
  _Predicate _M_pred;      // 内部成员
public:
  explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
  bool operator()(const typename _Predicate::argument_type& __x) const {
    return !_M_pred(__x);  // 将pred的运算结果加上否定（negate）运算
  }
};
// 辅助函数，以便于使用unary_negate<_Predicate> 
template <class _Predicate>
inline unary_negate<_Predicate> 
not1(const _Predicate& __pred)
{
  return unary_negate<_Predicate>(__pred);
}
// 以下适配器用来表示某个Adapter Binary Predicate的逻辑负值
template <class _Predicate> 
class binary_negate 
  : public binary_function<typename _Predicate::first_argument_type,
                           typename _Predicate::second_argument_type,
                           bool> {
protected:
  _Predicate _M_pred;             // 内部成员
public:
  explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
  bool operator()(const typename _Predicate::first_argument_type& __x, 
                  const typename _Predicate::second_argument_type& __y) const
  {
    return !_M_pred(__x, __y);    // 将pred的运算结果加上否定（negate）运算 
  }
};
// 辅助函数，便于使用binary_negate<_Predicate>
template <class _Predicate>
inline binary_negate<_Predicate> 
not2(const _Predicate& __pred)
{
  return binary_negate<_Predicate>(__pred);
}

    • 对参数进行绑定：bind1st，bind2nd

      // 以下配接器用来将某个Adapter Binary function转换为Unary Function
template <class _Operation> 
class binder1st
  : public unary_function<typename _Operation::second_argument_type,
                          typename _Operation::result_type> {
protected:
  _Operation op;    // 内部成员
  typename _Operation::first_argument_type value;  // 内部成员
public:
  binder1st(const _Operation& __x,
            const typename _Operation::first_argument_type& __y)
      : op(__x), value(__y) {}    // 将表达式和第一参数记录于内部成员
  typename _Operation::result_type
  operator()(const typename _Operation::second_argument_type& __x) const {
    return op(value, __x);        // 实际调用表达式，并将value绑定为第一参数
  }
};
// 辅助函数，方便应用binder1st<_Operation>
template <class _Operation, class _Tp>
inline binder1st<_Operation> 
bind1st(const _Operation& __fn, const _Tp& __x) 
{
  typedef typename _Operation::first_argument_type _Arg1_type;
  return binder1st<_Operation>(__fn, _Arg1_type(__x));
}
// 以下配接器用来将Adaptable Binary function转换为Unary Function
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);       // 实际调用表达式，并将value绑定为第二参数
  }
};
// 辅助函数，便于使用binder2nd<_Operation>
template <class _Operation, class _Tp>
inline binder2nd<_Operation> 
bind2nd(const _Operation& __fn, const _Tp& __x) 
{
  typedef typename _Operation::second_argument_type _Arg2_type;
  return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}

    • 用于函数合成：compose1，compose2

      // 已知两个Adapter Unary Functions f()，g()，以下配接器用来产生一个h()，使得h(x) = f(g(x))
template <class _Operation1, class _Operation2>
class unary_compose
  : public unary_function<typename _Operation2::argument_type,
                          typename _Operation1::result_type> 
{
protected:
  _Operation1 _M_fn1;   // 内部成员
  _Operation2 _M_fn2;   // 内部成员
public:
  unary_compose(const _Operation1& __x, const _Operation2& __y) 
    : _M_fn1(__x), _M_fn2(__y) {}    // 将两个表达式记录于内部成员
  typename _Operation1::result_type
  operator()(const typename _Operation2::argument_type& __x) const {
    return _M_fn1(_M_fn2(__x));      // 函数合成
  }
};
// 辅助函数，让我们得以方便运用unary_compose<_Operation1,_Operation2>
template <class _Operation1, class _Operation2>
inline unary_compose<_Operation1,_Operation2> 
compose1(const _Operation1& __fn1, const _Operation2& __fn2)
{
  return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
}
// 已知一个Adapter Binary Function f和两个Adaptable Unary Functions g1，g2
// 以下配接器用来产生一个h，使h(x) = f(g1(x), g2(x))
template <class _Operation1, class _Operation2, class _Operation3>
class binary_compose
  : public unary_function<typename _Operation2::argument_type,
                          typename _Operation1::result_type> {
protected:
  _Operation1 _M_fn1;     // 内部成员
  _Operation2 _M_fn2;     // 内部成员
  _Operation3 _M_fn3;     // 内部成员
public:
  binary_compose(const _Operation1& __x, const _Operation2& __y, 
                 const _Operation3& __z) 
    : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
  typename _Operation1::result_type
  operator()(const typename _Operation2::argument_type& __x) const {
    return _M_fn1(_M_fn2(__x), _M_fn3(__x));   // 函数合成
  }
};
// 辅助函数，让我们得以方便运用binary_compose<_Operation1,_Operation2,_Operation3>
template <class _Operation1, class _Operation2, class _Operation3>
inline binary_compose<_Operation1, _Operation2, _Operation3> 
compose2(const _Operation1& __fn1, const _Operation2& __fn2, 
         const _Operation3& __fn3)
{
  return binary_compose<_Operation1,_Operation2,_Operation3>
    (__fn1, __fn2, __fn3);
}

    • 用于函数指针：ptr_fun

      // 以下配接器其实就是把一个一元函数指针包起来；
// 当仿函数被使用时，就调用该函数指针
template <class _Arg, class _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result> {
protected:
  _Result (*_M_ptr)(_Arg);     // 内部成员，一个函数指针
public:
  pointer_to_unary_function() {}
  // 以下constructor将函数指针记录于内部成员之中
  explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
  // 通过函数指针执行函数
  _Result operator()(_Arg __x) const { return _M_ptr(__x); }
};
// 辅助函数，使我们能够方便运用pointer_to_unary_function
template <class _Arg, class _Result>
// pointer_to_unary_function<_Arg, _Result>是函数的返回值
inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
{
  return pointer_to_unary_function<_Arg, _Result>(__x);
}
// 以下配接器其实就是把一个二元函数指针包起来；
// 当仿函数被使用时，就调用该函数指针
template <class _Arg1, class _Arg2, class _Result>
class pointer_to_binary_function : 
  public binary_function<_Arg1,_Arg2,_Result> {
protected:
    _Result (*_M_ptr)(_Arg1, _Arg2);   // 内部成员，一个函数指针
public:
    pointer_to_binary_function() {}
    // 以下constructor将函数指针记录于内部成员之中
    explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) 
      : _M_ptr(__x) {}
    // 以下，通过函数指针执行函数
    _Result operator()(_Arg1 __x, _Arg2 __y) const {
      return _M_ptr(__x, __y);
    }
};
// 辅助函数，使我们能够方便运用pointer_to_binary_function
template <class _Arg1, class _Arg2, class _Result>
// pointer_to_binary_function<_Arg1,_Arg2,_Result>是函数的返回值
inline pointer_to_binary_function<_Arg1,_Arg2,_Result> 
ptr_fun(_Result (*__x)(_Arg1, _Arg2)) {
  return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x);
}

    • 用于成员函数指针：mem_fun，men_fun_ref

      // 这个族群一共有8 = 2^3个function objects
// 1)“无任何参数”vs“有一个参数”
// 2)“通过pointer调用”vs“通过refernece调用”
// 3)“const成员函数”vs“non-const成员函数”
// 所有复杂都只存在于function objects内部。可以忽略它们，直接使用更上层的辅助函数mem_fun和
// mem_fun_ref，它们会产生适当的配接器
// “无任何参数”、“通过pointer调用”、“non-const成员函数”
template <class _Ret, class _Tp>
class mem_fun_t : public unary_function<_Tp*,_Ret> {
public:
  explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}    // 记录下来
  _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); } // 转调用
private:
  _Ret (_Tp::*_M_f)();  // 内部成员，pointer to member function
};
// “无任何参数”、“通过pointer调用”、“const成员函数”
template <class _Ret, class _Tp>
class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
public:
  explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)() const;   // 内部成员，pointer to const member function 
};

// “无任何参数”、“通过reference调用”、“non-const成员函数”
template <class _Ret, class _Tp>
class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
  explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}  // 记录下来
  _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }    // 转调用
private:
  _Ret (_Tp::*_M_f)();   // 内部成员，pointer to member function
};
// “无任何参数”、“通过reference调用”、“const成员函数”
template <class _Ret, class _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
  explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)() const;   // 内部成员，pointer to const member function 
};
// “有一个参数”、“通过pointer调用”、“non-const成员函数”
template <class _Ret, class _Tp, class _Arg>
class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
public:
  explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}              // 转录下来
  _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }   // 转调用
private:
  _Ret (_Tp::*_M_f)(_Arg);    // 内部成员，pointer to member function 
};
// “有一个参数”、“通过pointer调用”、“const成员函数”
template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
public:
  explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  _Ret operator()(const _Tp* __p, _Arg __x) const
    { return (__p->*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg) const;   // 内部成员，pointer to const member function
};
// “有一个参数”、“通过reference调用”、“non-const成员函数”
template <class _Ret, class _Tp, class _Arg>
class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
  explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}        // 记录下来
  _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }  // 转调用
private:
  _Ret (_Tp::*_M_f)(_Arg);    // 内部成员，pointer to member function
};
// “有一个参数”、“通过reference调用”、“const成员函数”
template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
  explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg) const;   // 内部成员，pointer to const member function
};

// mem_fun adapter的辅助函数：mem_fun，mem_fun_ref
template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
// 以下四个函数，其实可以采用和先前（以上）四个函数相同的名称（函数重载）
template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

  • 参考文献

    STL源码剖析——侯捷

    STL源码

Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生