迭代器基类
struct input_iterator_tag
{
} ;
struct output_iterator_tag
{
} ;
struct forward_iterator_tag : public input_iterator_tag
{
} ;
struct bidirectional_iterator_tag : public forward_iterator_tag
{
} ;
struct random_access_iterator_tag : public bidirectional_iterator_tag
{
} ;
template < class Category , class T , class Distance = ptrdiff_t,
class Pointer = T * , class Reference = T & >
class iterator
{
public :
using iterator_category = Category;
using value_type = T;
using difference = Distance;
using pointer = Pointer;
using reference = Reference;
} ;
迭代器萃取
template < class T >
class iterator_traits
{
public :
using iterator_category = typename T :: iterator_category;
using value_type = typename T :: value_type;
using difference_type = typename T :: difference_type;
using pointer = typename T :: pointer;
using reference = typename T :: reference;
} ;
迭代器萃取机的偏特化
template < class T >
class iterator_traits < T * >
{
public :
using iterator_category = random_access_iterator_tag;
using value_type = T;
using difference_type = ptrdiff_t;
using pointer = T * ;
using reference = T & ;
} ;
template < class T >
class iterator_traits < const T * >
{
public :
using iterator_category = random_access_iterator_tag;
using value_type = T;
using difference_type = ptrdiff_t;
using pointer = const T * ;
using reference = const T & ;
} ;
萃取出的类型
template < class T >
using iterator_category_t =
typename iterator_traits < T> :: iterator_category;
template < class T >
using value_type_t =
typename iterator_traits < T> :: value_type;
template < class T >
using difference_type_t =
typename iterator_traits < T> :: difference_type;
template < class T >
using pointer_t =
typename iterator_traits < T> :: pointer_t;
template < class T >
using reference_t =
typename iterator_traits < T> :: reference_t;
移动和计算距离
template < class T >
inline difference_type_t< T> __distance ( T first, T last, input_iterator_tag)
{
difference_type_t< T> n = 0 ;
while ( first != last)
{
++ first;
++ n;
}
return n;
}
template < class T >
inline difference_type_t< T> __distance ( T first, T last, random_access_iterator_tag)
{
return last - first;
}
template < class T1 >
inline difference_type_t< T1> distance ( T1 first, T1 last)
{
return __distance ( first, last, iterator_category_t < T1> ( ) ) ;
}
template < class T , class F >
inline void __advance ( T & it, F n, input_iterator_tag)
{
while ( n-- )
{
++ it;
}
}
template < class T , class F >
inline void __advance ( T & it, F n, bidirectional_iterator_tag)
{
if ( n >= 0 )
{
while ( n-- )
{
++ it;
}
}
else
{
while ( n++ )
{
-- it;
}
}
}
template < class T , class F >
inline void __advance ( T & it, F n, random_access_iterator_tag)
{
it += n;
}
template < class T , class F >
inline void advance ( T& it, F n)
{
__advance ( it, n, iterator_category_t < T> ( ) ) ;
}
三种迭代器适配器 insert reverse stream
insert
template < class T >
class back_insert_iterator
{
protected :
T * container;
public :
using iterator_category = output_iterator_tag;
using value_type = void ;
using difference_type = void ;
using pointer = void ;
using reference = void ;
public :
explicit back_insert_iterator ( T & value) : container ( value) { }
back_insert_iterator& operator = ( const typename T :: value_type & value)
{
container-> push_back ( value) ;
return * this ;
}
back_insert_iterator operator * ( )
{
return * this ;
}
back_insert_iterator operator ++ ( )
{
return * this ;
}
back_insert_iterator operator ++ ( int )
{
return this ;
}
} ;
template < class T >
inline back_insert_iterator< T> back_inserter ( T& x)
{
return back_insert_iterator < T> ( x) ;
}
template < class T >
class front_insert_iterator
{
protected :
T * container;
public :
using iterator_category = output_iterator_tag;
using value_type = void ;
using difference_type = void ;
using pointer = void ;
using reference = void ;
public :
explicit front_insert_iterator ( T& value) : container ( value) { }
front_insert_iterator& operator = ( const typename T :: value_type& value)
{
container-> push_front ( value) ;
return * this ;
}
front_insert_iterator operator * ( )
{
return * this ;
}
front_insert_iterator operator ++ ( )
{
return * this ;
}
front_insert_iterator operator ++ ( int )
{
return * this ;
}
} ;
template < class T >
inline front_insert_iterator< T> front_insert ( T& x)
{
return front_insert_iterator < T> ( x) ;
}
template < class T >
class insert_iterator
{
protected :
T* container;
typename T :: iterator iter;
public :
using iterator_category = output_iterator_tag;
using value_type = void ;
using difference_type = void ;
using pointer = void ;
using reference = void ;
public :
insert_iterator ( T& value, typename T :: iterator i)
: container ( value) , iter ( i) { }
insert_iterator & operator = ( const typename T :: value_type & value)
{
container-> insert ( iter, value) ;
++ iter;
return * this ;
}
insert_iterator operator * ( )
{
return * this ;
}
insert_iterator operator ++ ( )
{
return * this ;
}
insert_iterator operator ++ ( int )
{
return * this ;
}
} ;
template < class T , class It >
inline insert_iterator< T> inserter ( T& x, It it)
{
return insert_iterator < T> ( x, it) ;
}
reverse
template < class T >
class __reverse_iterator
{
public :
template < class IT >
friend bool operator == ( const __reverse_iterator < IT> & , const __reverse_iterator < IT> & ) ;
template < class IT >
friend bool operator != ( const __reverse_iterator < IT> & , const __reverse_iterator < IT> & ) ;
protected :
T current;
public :
using iterator_category = iterator_category_t< T> ;
using value_type = value_type_t< T> ;
using difference_type = difference_type_t< T> ;
using pointer = pointer_t< T> ;
using reference = reference_t< T> ;
using iterator_type = T;
using self = __reverse_iterator;
public :
__reverse_iterator ( ) { }
explicit __reverse_iterator ( iterator_type value) : current ( value) { }
__reverse_iterator ( const self& value) : current ( value. current) { }
iterator_type base ( ) const
{
return current;
}
reference operator * ( ) const
{
T temp = current;
return * ( -- temp) ;
}
pointer operator -> ( ) const
{
return & ( operator * ( ) ) ;
}
self& operator ++ ( )
{
-- current;
return * this ;
}
self operator ++ ( int )
{
self cp = * this ;
-- current;
return cp;
}
self& operator -- ( )
{
++ current;
return * this ;
}
self operator -- ( int )
{
self cp = this ;
current++ ;
return cp;
}
self operator + ( difference_type n) const
{
return self ( current - n) ;
}
self operator - ( difference_type n) const
{
return self ( current + n) ;
}
self& operator += ( difference_type n)
{
current -= n;
return * this ;
}
self& operator -= ( difference_type n)
{
current += n;
return * this ;
}
reference operator [ ] ( difference_type n) const
{
return * ( * this + n) ;
}
bool operator == ( const self& rhs) const
{
return current == rhs. current;
}
bool operator != ( const self& rhs) const
{
return ! ( this != & this ) ;
}
} ;
template < class T >
inline bool operator == ( const __reverse_iterator< T> & lhs, const __reverse_iterator< T> & rhs)
{
return lhs == rhs;
}
template < class T >
inline bool operator != ( const __reverse_iterator< T> & lhs, const __reverse_iterator< T> & rhs)
{
return ! ( lhs != rhs) ;
}
template < class T >
inline bool operator < ( const __reverse_iterator< T> & lhs, const __reverse_iterator< T> & rhs)
{
return rhs. base ( ) < lhs. base ( ) ;
}
template < class T >
inline bool operator > ( const __reverse_iterator< T> & lhs, const __reverse_iterator< T> & rhs)
{
return rhs. base ( ) > lhs. base ( ) ;
}
template < class T >
inline bool operator <= ( const __reverse_iterator< T> & lhs, const __reverse_iterator< T> & rhs)
{
return ! ( lhs > rhs) ;
}
template < class T >
inline bool operator >= ( const __reverse_iterator< T> & lhs, const __reverse_iterator< T> & rhs)
{
return ! ( lhs < rhs) ;
}
stream
template < class T , class Distance = ptrdiff_t>
class istream_iterator
{
protected :
std:: istream * stream;
T value;
bool end_maker;
void read ( )
{
end_maker = ( * stream) ? true : false ;
if ( end_maker == true )
{
* stream >> value;
}
end_maker = ( * stream) ? true : false ;
}
public :
using iterator_category = input_iterator_tag;
using value_type = T;
using difference_type = Distance;
using pointer = const T* ;
using reference = const T& ;
istream_iterator ( ) : stream ( & std:: cin) , end_maker ( false ) { }
istream_iterator ( std:: istream & s) : stream ( s)
{
read ( ) ;
}
reference operator * ( ) const
{
return value;
}
pointer operator -> ( ) const
{
return & ( operator * ( ) ) ;
}
istream_iterator & operator ++ ( )
{
read ( ) ;
return * this ;
}
istream_iterator operator ++ ( int )
{
istream_iterator cp = * this ;
read ( ) ;
return cp;
}
} ;
template < class T >
class ostream_iterator
{
protected :
std:: ostream* stream;
const char * interval;
public :
using iterator_category = output_iterator_tag;
using value_type = void ;
using difference_type = void ;
using pointer = void ;
using reference = void ;
ostream_iterator & operator = ( const T & value)
{
* stream << value;
if ( interval)
{
* stream << interval;
}
return * this ;
}
ostream_iterator & operator * ( )
{
return * this ;
}
ostream_iterator& operator ++ ( )
{
return * this ;
}
ostream_iterator& operator ++ ( int )
{
return * this ;
}
} ;