标签：
定义
配接器（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源码
标签：
原文地址：http://blog.csdn.net/yzhang6_10/article/details/51298729
