//---------------------------15/04/03----------------------------
/*
配接器概述：
1:adapter是一种设计模式：将一个class的接口转换为另一个class的接口，使得原本因接口不兼容而
不能合作的classes可以一起工作。
2:改变仿函数接口的，称为function adapter，改变容器接口的，称为container adapter，
改变迭代器接口的，称为iterator adapter。
3:container adatper： queue
， stack
4:iterator adapter ： insert iterators， reverse iterators，iostream iterators。
1>insert iterators：把赋值操作转变成插入操作，有三个相应函数：
back_inserter(Container& x),front_inserter(Container& x),inserter(Container& x);
2>Reverse iterators:把迭代器转变成反向迭代器的adapter；
3>iostream iterators：将迭代器绑定到iostream对象身上，实现相应的输入输出功能。
5:functor adapter ：包括bind，negate，compose，ptr fun，mem
fun
辅助函数
实际效果
实际产生的对象
bind1st(const Op& op, op(x, param); binder1st<Op>
const T& x); (op, arg1_type(x))
bind2nd(const Op& op, op(param, x); binder2nd<Op>
const T& x); (op, arg2_type(x))
not1(const Pred& pred); !pred(param); unary_negate<Pred>(pred)
not2(const Pred& pred); !pred(param1, binary_negate<Pred>(pred)
param2);
compose1(const Op1& op1, op1(op2(param)); unary_compose<Op1,Op2>
const Op2& op2); (op1, op2)
compose1(const Op1& op1, op1(op2(param), unary_compose<Op1,Op2>
const Op2& op2, op3(param)) (op1, op2, op3)
const Op3& op3);
ptr_fun(Result(*fp)(Arg)); fp(param); pointer_to_unary_function
<Arg, Result>(fp)
ptr_fun(Result(*fp) fp(param1,param2); pointer_to_binary_function
(Arg1,Arg2) <Arg1, Arg2, Result>(fp)
mem_fun(S (T::*f)()); (param->*f)(); mem_fun_t<S, T>(f)
mem_fun(S (T::*f)() const); (param->*f)(); const_mem_fun_t<S, T>(f)
mem_fun_ref(S (T::*f)()); (param.*f)(); mem_fun_ref_t<S, T>(f)
mem_fun_ref(S (T::*f)() (param.*f)(); const_mem_fun_ref_t<S, T>(f)
const);
mem_fun1(S (T::*f)(A)); (param->*f)(x); mem_fun1_t<S, T, A>(f)
mem_fun1(S (T::*f)(A) const); (param->*f)(x); const_mem_fun1_t<S, T, A>(f)
mem_fun1_ref(S (T::*f)(A)); (param.*f)(x); mem_fun1_ref_t<S, T, A>(f)
mem_fun1_ref(S (T::*f)(A) (param.*f)(x); const_mem_fun1_ref_t<S, T, A>(f)
const);
*/
//back_insert_iterator
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) {}
//唯一要注意的点，把赋值操作改成了push_back操作
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;}
};
//辅助函数，用来返回一个back_insert_iterator对象，使用辅助函数可以使的使用变简单。
template<class Container>
inline back_insert_iterator<Container> back_insert(Container& x)
{
return back_insert_iterator<Container>(x);
}
//front_insert_iterator
template<class Container>
class front_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 front_insert_iterator(Container& x) : container(&x) {}
//注意，迭代器指向的容器要有push_front操作才行
front_insert_iterator<Container>&
operator=(const
typename Container::value_type& value)
{
container->push_front(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;}
};
//辅助函数，用来返回一个front_insert_iterator对象，
template<class Container>
inline front_insert_iterator<Container> front_insert(Container& x)
{
return front_insert_iterator<Container>(x);
}
//insert_iterator
template<class Container>
class front_insert_iterator
{
protected:
Container* container;
typename Container::iterator iter;
public:
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
explicit 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);
++iter;
return *this;
}
//禁止* ++的操作
insert_iterator<Container>&
operator*() {return *this;}
insert_iterator<Container>&
operator++() {return *this;}
insert_iterator<Container>&
operator++(int) {return *this;}
};
//辅助函数，用来返回一个insert_iterator对象，
template<class Container>
inline insert_iterator<Container> front_insert(Container& x, iterator i)
{
typedef typename Container::iterator iter;
return insert_iterator<Container>(x, iter(i));
}
//reverse_iterator
template<class Iterator>
class reverse_iterator
{
protected:
Iterator current;
public:
typedef typename iterator_traits<Iterator>::iterator_category
iterator_category;
typedef typename iterator_traits<Iterator>::value_type
value_type;
typedef typename iterator_traits<Iterator>::difference_type
difference_type;
typedef typename iterator_traits<Iterator>::pointer
pointer;
typedef typename iterator_traits<Iterator>::reference
reference;
typedef Iterator iterator_type;
typedef reverse_iterator<Iterator> self;
public:
reverse_iterator(){}
explicit reverse_iterator(iterator_type x): current(x) {}
reverse_iterator(const self& x): current(x.current) {}
iterator_type base()
const { return current; }
reference
operator*() const
{
Iterator tmp = current;
return *--tmp;
}
pointer
operator->() const {
return &(operator*());}
self&
operator++()
{
--current;
return *this;
}
self
operator++(int)
{
self tmp = *this;
--current;
return tmp;
}
self&
operator--()
{
++current;
return *self;
}
self
operator--(int)
{
Iterator tmp = current;
++current;
return tmp;
}
self
operator+(difference_type n)
const
{
return self(current - n);
}
self&
operator+=(difference_type n)
{
current -= n;
return *this;
}
self
operator-(difference_type n)
const
{
return self(current + n);
}
self&
operator-=(difference_type n)
{
current +=n;
return *this;
}
//第二个this
是
指向 自己的指针，第二个星号不会调用operator*，
//*this是一个reverse_iterator对象，+
和
第一个* 都会调用operator操作
reference
operator[](difference_type n)
const
{
return *(*this + n);
}
};
//stream iterators
//istream_iterator
template<class T,
class Distance = ptrdiff_t>
class istream_iterator
{
firend
bool
operator== __STL_NULL_TMPL_ARGS(const istream_iterator<T, Distance>& x,
const istream_iterator<T, Distance>& y);
protected:
istream* stream;
T value;
bool end_marker;//输入结束标识
void read()
{
//看stream能否读取到数据，能就设置true，否则设置false
end_marker = (*stream) ?
true : false;
if(end_marker)
*stream >> value;
end_marker = (*stream) ?
true : false;
}
public:
typedef input_iterator_tag iterator_category;
typedef T value_type;
typedef Distance difference_type;
typedef const T* pointer;
typedef const T& reference;
//默认是cin，不会读数据
istream_iterator(): stream(&cin), end_marker(false){}
//如果自己传入一个istream
会马上调用read()，然后就会读数据了
istream_iterator(istream& s): stream(&s) {read();}
reference
operator*() const {
return value;}
pointer
operator->() const {
return &(operator*());}
istream_iterator<T, Distance>&
operator++()
{
read();
return *this;
}
istream_iterator<T, Distance>
operator++(int)
{
istream_iterator<T, Distance> tmp = *this;
read();
return tmp;
}
};
//ostream_iterator
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(){}
ostream_iterator(ostream& s,
const char* c):stream(&s), string(c) {};
//改写赋值操作为输出到ostream
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;}
};
//function adapters
//unary_negate
template<class Predicate>
class unary_negate :
public unary_function<typename Predicate::
argument_type,
bool>
{
protected:
Predicate pred;
public:
explicit unary_negate(const Predicate& x):pred(x) {}
bool operator()(const
typename Predicate::argument_type& x)
const
{
return !pred(x);
}
};
template<class Predicate>
inline unary_negate<Predicate> not1(const Predicate& pred)
{
return unary_negate<Predicate>(pred);
}
//binary_negate
template<class Predicate>
class binary_negate :
public binary_function
<typename Predicate::first_argument_type,
typename Predicate::second_argument_type,bool>
{
protected:
Predicate pred;
public:
explicit binary_negate(const Predicate& x): pred(x) {}
bool operator()(const
typename Predicate::first_argument_type& x,
const typename Predicate::second_argument_type& y)
const
{
return !pred(x, y);
}
};
template<class Predicate>
inline binary_negate<Predicate> not2(const Predicate& pred)
{
return binary_negate<Predicate>(pred);
}
//binder1st
template<class Operation>
class binder1st:
public unary_function<typename Operation::second_argument_type,
typename Operation::result_type>
//绑定后就变成unary_function了
{
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);
}
};
template<class Operation,
class T>
inline binder1st<Operation> bind1st(const Operation& op,
const T& x)
{
typedef typename Operation::first_argument_type arg1_type;
return binder1st<Operation>(op, arg1_type(x));
}
//binder2nd
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);
}
};
template<class Operation,
class T>
inline binder2nd<Operation> bind2nd(const Operation& op,
const T& x)
{
typedef typename Operation::second_argument_type arg2_type;
return binder2nd<Operation>(op, arg2_type(x));
}
//unary_compose
template<class Operation1,
class Operation2>
class unary_compose :
public unary_function<typename Operation2::argument_type,
typename Operation1::result_type>
{
protected:
Operation1 op1;
Operation2 op2;
public:
unary_compose(const Operation1& x,
const Operation2& y): op1(x), op2(y) {}
typename Operation2::result_type
operator()(const
typename Operation2::argument_type& x)
{
return op1(op2(x));
}
};
template<class Operation1,
class Operation2>
inline unary_compose<Operation1, Operation2>
compose1(const Operation1& op1,
const Operation2& op2)
{
return unary_compose<Operation1, Operation2>(op1, op2);
}
//binary_compose
template<class Operation1,
class Operation2,
class Operation3>
class binary_compose :
public unary_function<typename Operation2::argument_type,
typename Operation1::result_type>
{
protected:
Operation1 op1;
Operation2 op2;
Operation3 op3;
public:
binary_compose(const Operation1& x,
const Operation2& y,
const Operation3& z)
:op1(x), op2(y), op3(z) {}
typename Operation1::result_type
operator()(const
typename Operation2::argument_type& x)
const
{
return op1(op2(x), op3(x));
}
};
template<class Operation1,
class Operation2,
class Operation3>
inline binary_compose<Operation1, Operation2, Operation3>
compose2(const Operation1& op1,
const Operation2& op2,
const Operation3& op3)
{
return binary_compose<Operation1, Operation2, Operation3>(op1, op2, op3);
}
//ptr_fun
//pointer_to_unary_function
template<class Arg,
class Result>
class pointer_to_unary_function :
public unary_function<Arg, Result>
{
protected:
Result (*ptr)(Arg);
public:
pointer_to_unary_function(){}
explicit pointer_to_unary_function(Result (*x)(Arg)) : ptr(x) {}
Result
operator()(Arg x)
const {return ptr(x); }
};
template<class Arg,
class Result>
inline pointer_to_unary_function<Arg, Result>
ptr_fun(Result (*x)(Arg))
{
return pointer_to_unary_function<Arg, Result>(x);
}
//pointer_to_binary_function
template<class Arg1,
class Arg2, class Result>
class pointer_to_binary_function :
public binary_function<Arg1, Arg2, Result>
{
protected:
Result (*ptr)(Arg1, Arg2)
public:
pointer_to_binary_function(){}
explicit pointer_to_binary_function(Result (*x)(Arg1, Arg2))
: ptr(x) {}
Result
operator()(Arg1, Arg2)
const {return ptr(x, y); }
};
template<class Arg1,
class Arg2, class Result>
inline pointer_to_unary_function<Arg1, Arg2, Result>
ptr_fun(Result (*x)(Arg1, Arg2))
{
return pointer_to_binary_function<Arg1, Arg2, Result>(x);
}
//mem_fun
//mem_fun_t
template<class S,
class T>
class mem_fun_t :
public unary_function<T*, S>
{
public:
explicit mem_fun_t(S (T::*pf)) : f(pf) {}
S
operator()(T* p) const {
return (p->*f)(); }
private:
S (T::*f)();
};
//cosnt_mem_fun_t
template<class S,
class T>
class cosnt_mem_fun_t :
public unary_function<const T*, S>
{
public:
explicit cosnt_mem_fun_t(S (T::*pf)
const) : f(pf) {}
S
operator()(const T* p)
const { return (p->*f)(); }
private:
S (T::*f)()
const;
};
//mem_fun_ref_t
template<class S,
class T>
class mem_fun1_ref_t :
public unary_function<T, S>
{
public:
explicit mem_fun1_ref_t(S (T::*pf)()) : f(pf) {}
S
operator()(T& r) {
return (r.*f)();}
private:
S (T::*f)();
};
//const_mem_fun_ref_t
template<class S,
class T>
class const_mem_fun_ref_t :
public unary_function<T, S>
{
public:
const_mem_fun_ref_t(S (T::*pf)()
const) : f(pf) {}
S
operator()(const T& r)
const { return (r.*f)();}
private:
S (T::*f)()
const;
};
//mem_fun1_t
template<class S,
class T, class A>
class mem_fun1_t : binary_function<T*, A, S>
{
public:
mem_fun1_t(S (T::*pf)(A)) : f(pf) {}
S
operator()(T* p, A x) {
return (p->*f)(x); }
private:
S (T::*f)(A);
};
//const_mem_fun1_t
template<class S,
class T, class A>
class const_mem_fun1_t :
public binary_function<const T*, A, S>
{
public:
const_mem_fun1_t(S (T::*pf)
const ) : f(pf) {}
S
operator()(const T* p, A x)
const { return (p->*f)(x); }
private:
S (T::*f)(A)
const;
};
//mem_fun1_ref_t
template<class S,
class T, class A>
class mem_fun1_ref_t : binary_function<T, A, S>
{
public:
mem_fun1_ref_t(S (T::*pf)(A)) : f(pf) {}
S
operator()(T& r, A x) {
return (r.*f)(x); }
private:
S (T::*f)(A);
};
//const_mem_fun1_ref_t
template<class S,
class T, class A>
class const_mem_fun1_ref_t :
public binary_function<T, A, S>
{
public:
const_mem_fun1_ref_t(S (T::*pf)
const ) : f(pf) {}
S
operator()(const T& r, A x)
const { return (r.*f)(x); }
private:
S (T::*f)(A)
const;
};
//各个辅助函数
//fun
template<class S,
class T>
inline mem_fun_t<S,T> mem_fun(S (T::*f)())
{
return mem_fun_t<S,T>(f);
}
template<class S,
class T>
inline const_mem_fun_t<S,T> mem_fun(S (T::*f)()
const)
{
return const_mem_fun_t<S,T>(f);
}
template<class S,
class T>
inline mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)())
{
return mem_fun_ref_t<S,T>(f);
}
template<class S,
class T>
inline const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()
const)
{
return const_mem_fun_ref_t<S,T>(f);
}
//fun1
template<class S,
class T, class A>
inline mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A))
{
return mem_fun1_t<S,T,A>(f);
}
template<class S,
class T, class A>
inline const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)
const)
{
return const_mem_fun1_t<S,T,A>(f);
}
template<class S,
class T, class A>
inline mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A))
{
return mem_fun1_ref_t<S,T,A>(f);
}
template<class S,
class T, class A>
inline const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)
const)
{
return const_mem_fun1_ref_t<S,T,A>(f);
}