stl源码剖析 详细学习笔记 配接器

//---------------------------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);

}