stl_iterator.h

stl_iterator.h
// Filename:    stl_iterator.h
 
// Comment By:  凝霜
// E-mail:      mdl2009@vip.qq.com
// Blog:        http://blog.csdn.net/mdl13412
 
/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1996,1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 */
 
/* NOTE: This is an internal header file, included by other STL headers.
 *   You should not attempt to use it directly.
 */
 
#ifndef __SGI_STL_INTERNAL_ITERATOR_H
#define __SGI_STL_INTERNAL_ITERATOR_H
 
__STL_BEGIN_NAMESPACE
 
////////////////////////////////////////////////////////////////////////////////
// STL迭代器定义
////////////////////////////////////////////////////////////////////////////////
// STL中有五种迭代器类型
// Input Iterator               read only
// Output Iterator              write only
// Forward Iterator             允许"写入型"算法在其指向区间进行操作
// Bidirectional Iterator       提供双向访问能力
// Random Access Iterator       支持原生指针具有的全部能力
////////////////////////////////////////////////////////////////////////////////
// 类型从属关系, 子类适用于接受父类类型的算法, 但是效率可能不佳
//
//              Input Iterator
//                    ↑
//             Forward Iterator
//                    ↑
//           Bidirectional Iterator
//                    ↑
//           Random Access Iterator
////////////////////////////////////////////////////////////////////////////////
 
// 用于标记迭代器类型
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 T, class Distance> struct input_iterator
{
  typedef input_iterator_tag iterator_category;
  typedef T                  value_type;
  typedef Distance           difference_type;
  typedef T*                 pointer;
  typedef T&                 reference;
};
 
struct output_iterator
{
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;
};
 
template <class T, class Distance> struct forward_iterator
{
  typedef forward_iterator_tag iterator_category;
  typedef T                    value_type;
  typedef Distance             difference_type;
  typedef T*                   pointer;
  typedef T&                   reference;
};
 
template <class T, class Distance> struct bidirectional_iterator
{
  typedef bidirectional_iterator_tag iterator_category;
  typedef T                          value_type;
  typedef Distance                   difference_type;
  typedef T*                         pointer;
  typedef T&                         reference;
};
 
template <class T, class Distance> struct random_access_iterator
{
  typedef random_access_iterator_tag iterator_category;
  typedef T                          value_type;
  typedef Distance                   difference_type;
  typedef T*                         pointer;
  typedef T&                         reference;
};
 
#ifdef __STL_USE_NAMESPACES
template <class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
struct iterator {
  typedef Category  iterator_category;
  typedef T         value_type;
  typedef Distance  difference_type;
  typedef Pointer   pointer;
  typedef Reference reference;
};
#endif /* __STL_USE_NAMESPACES */
 
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
 
////////////////////////////////////////////////////////////////////////////////
// iterator_traits定义
////////////////////////////////////////////////////////////////////////////////
 
// 用于traits出迭代其所指对象的型别
template <class Iterator>
struct iterator_traits
{
  // 迭代器类型, STL提供五种迭代器
  typedef typename Iterator::iterator_category iterator_category;
 
  // 迭代器所指对象的型别
  // 如果想与STL算法兼容, 那么在类内需要提供value_type定义
  typedef typename Iterator::value_type        value_type;
 
  // 这个是用于处理两个迭代器间距离的类型
  typedef typename Iterator::difference_type   difference_type;
 
  // 直接指向对象的原生指针类型
  typedef typename Iterator::pointer           pointer;
 
  // 这个是对象的引用类型
  typedef typename Iterator::reference         reference;
};
 
// 针对指针提供特化版本
template <class T>
struct iterator_traits<T*>
{
  typedef random_access_iterator_tag iterator_category;
  typedef T                          value_type;
  typedef ptrdiff_t                  difference_type;
  typedef T*                         pointer;
  typedef T&                         reference;
};
 
// 针对指向常对象的指针提供特化
template <class T>
struct iterator_traits<const T*>
{
  typedef random_access_iterator_tag iterator_category;
  typedef T                          value_type;
  typedef ptrdiff_t                  difference_type;
  typedef const T*                   pointer;
  typedef const T&                   reference;
};
 
////////////////////////////////////////////////////////////////////////////////
// iterator_traits支持函数
////////////////////////////////////////////////////////////////////////////////
// iterator_category(const Iterator&)           返回迭代器类别
// distance_type(const Iterator&)               返回表示迭代器距离的类型
// value_type(const Iterator&)                  返回迭代器所指对象的类型
////////////////////////////////////////////////////////////////////////////////
 
template <class Iterator>
inline typename iterator_traits<Iterator>::iterator_category
iterator_category(const Iterator&)
{
  typedef typename iterator_traits<Iterator>::iterator_category category;
  return category();
}
 
template <class Iterator>
inline typename iterator_traits<Iterator>::difference_type*
distance_type(const Iterator&)
{
  return static_cast<typename iterator_traits<Iterator>::difference_type*>();
}
 
template <class Iterator>
inline typename iterator_traits<Iterator>::value_type*
value_type(const Iterator&)
{
  return static_cast<typename iterator_traits<Iterator>::value_type*>();
}
 
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
// 编译器不支持partial specialization of class templates(模板类偏特化)
// 需要对所有迭代器类型都提供定义
 
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const input_iterator<T, Distance>&)
{
  return input_iterator_tag();
}
 
inline output_iterator_tag iterator_category(const output_iterator&)
{
  return output_iterator_tag();
}
 
template <class T, class Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<T, Distance>&)
{
  return forward_iterator_tag();
}
 
template <class T, class Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<T, Distance>&)
{
  return bidirectional_iterator_tag();
}
 
template <class T, class Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<T, Distance>&)
{
  return random_access_iterator_tag();
}
 
template <class T>
inline random_access_iterator_tag iterator_category(const T*)
{
  return random_access_iterator_tag();
}
 
template <class T, class Distance>
inline T* value_type(const input_iterator<T, Distance>&)
{
  return (T*)();
}
 
template <class T, class Distance>
inline T* value_type(const forward_iterator<T, Distance>&)
{
  return (T*)();
}
 
template <class T, class Distance>
inline T* value_type(const bidirectional_iterator<T, Distance>&)
{
  return (T*)();
}
 
template <class T, class Distance>
inline T* value_type(const random_access_iterator<T, Distance>&)
{
  return (T*)();
}
 
template <class T>
inline T* value_type(const T*) { return (T*)(); }
 
template <class T, class Distance>
inline Distance* distance_type(const input_iterator<T, Distance>&)
{
  return (Distance*)();
}
 
template <class T, class Distance>
inline Distance* distance_type(const forward_iterator<T, Distance>&)
{
  return (Distance*)();
}
 
template <class T, class Distance>
inline Distance*
distance_type(const bidirectional_iterator<T, Distance>&)
{
  return (Distance*)();
}
 
template <class T, class Distance>
inline Distance*
distance_type(const random_access_iterator<T, Distance>&)
{
  return (Distance*)();
}
 
template <class T>
inline ptrdiff_t* distance_type(const T*) { return (ptrdiff_t*)(); }
 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
////////////////////////////////////////////////////////////////////////////////
// template <class InputIterator, class Distance>
// inline void distance(InputIterator first, InputIterator last, Distance& n)
////////////////////////////////////////////////////////////////////////////////
//                                distance
//                                   |
//                                   |---------------- 判断迭代器类型
//                 Input Iterator    ↓   Random Access Iterator
//               -------------------------------------------
//               |                                         |
//               |                                         |
//               ↓                                         |
// __distance(..., input_iterator_tag)                     |
// while (first != last) { ++first; ++n; }                 |
//                                                         ↓
//                                __distance(..., random_access_iterator_tag)
//                                n += last - first;
////////////////////////////////////////////////////////////////////////////////
 
template <class InputIterator, class Distance>
inline void __distance(InputIterator first, InputIterator last, Distance& n,
                       input_iterator_tag)
{
  while (first != last) { ++first; ++n; }
}
 
template <class RandomAccessIterator, class Distance>
inline void __distance(RandomAccessIterator first, RandomAccessIterator last,
                       Distance& n, random_access_iterator_tag)
{
  n += last - first;
}
 
template <class InputIterator, class Distance>
inline void distance(InputIterator first, InputIterator last, Distance& n)
{
  __distance(first, last, n, iterator_category(first));
}
 
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
 
////////////////////////////////////////////////////////////////////////////////
// template <class InputIterator>
// inline iterator_traits<InputIterator>::difference_type
// distance(InputIterator first, InputIterator last)
////////////////////////////////////////////////////////////////////////////////
//                                distance
//                                   |
//                                   |---------------- 判断迭代器类型
//                 Input Iterator    ↓   Random Access Iterator
//               -------------------------------------------
//               |                                         |
//               |                                         |
//               ↓                                         |
// __distance(..., input_iterator_tag)                     |
// while (first != last) {                                 |
//    ++first; ++n;                                        |
// }                                                       |
// return n;                                               |
//                                                         ↓
//                                __distance(..., random_access_iterator_tag)
//                                return last - first;
////////////////////////////////////////////////////////////////////////////////
 
template <class InputIterator>
inline iterator_traits<InputIterator>::difference_type
__distance(InputIterator first, InputIterator last, input_iterator_tag)
{
  iterator_traits<InputIterator>::difference_type n = ;
  while (first != last) {
    ++first; ++n;
  }
  return n;
}
 
template <class RandomAccessIterator>
inline iterator_traits<RandomAccessIterator>::difference_type
__distance(RandomAccessIterator first, RandomAccessIterator last,
           random_access_iterator_tag)
{
  return last - first;
}
 
template <class InputIterator>
inline iterator_traits<InputIterator>::difference_type
distance(InputIterator first, InputIterator last)
{
  typedef typename iterator_traits<InputIterator>::iterator_category category;
  return __distance(first, last, category());
}
 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
////////////////////////////////////////////////////////////////////////////////
// advance()实现部分
////////////////////////////////////////////////////////////////////////////////
//                                advance
//                                   |
//                                   |---------------- 判断迭代器类型
//     Input Iterator                ↓
//   ---------------------------------------------------------------------
//   |             Random Access Iterator |      Bidirectional Iterator  |
//   |                                    |                              |
//   ↓                                    |                              |
// __advance(..., input_iterator_tag)     |                              |
// while (n--) ++i;                       |                              |
//                                        |                              |
//                                        ↓                              |
//               __advance(..., random_access_iterator_tag)              |
//               i += n;                                                 |
//                                                                       |
//                                                                       ↓
//                                   __advance(..., bidirectional_iterator_tag)
//                                   if (n >= 0)
//                                      while (n--) ++i;
//                                   else
//                                      while (n++) --i;
////////////////////////////////////////////////////////////////////////////////
 
template <class InputIterator, class Distance>
inline void __advance(InputIterator& i, Distance n, input_iterator_tag)
{
  while (n--) ++i;
}
 
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1183
#endif
 
template <class BidirectionalIterator, class Distance>
inline void __advance(BidirectionalIterator& i, Distance n,
                      bidirectional_iterator_tag)
{
  if (n >= )
    while (n--) ++i;
  else
    while (n++) --i;
}
 
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1183
#endif
 
template <class RandomAccessIterator, class Distance>
inline void __advance(RandomAccessIterator& i, Distance n,
                      random_access_iterator_tag)
{
  i += n;
}
 
template <class InputIterator, class Distance>
inline void advance(InputIterator& i, Distance n)
{
  __advance(i, n, iterator_category(i));
}
 
////////////////////////////////////////////////////////////////////////////////
// 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
  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; }
};
 
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
 
// 用于traits出back_insert_iterator的迭代器类别
template <class Container>
inline output_iterator_tag
iterator_category(const back_insert_iterator<Container>&)
{
  return output_iterator_tag();
}
 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
template <class Container>
inline back_insert_iterator<Container> back_inserter(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
  front_insert_iterator<Container>&
  operator=(const typename Container::value_type& value)
  {
    container->push_front(value);
    return *this;
  }
  front_insert_iterator<Container>& operator*() { return *this; }
  front_insert_iterator<Container>& operator++() { return *this; }
  front_insert_iterator<Container>& operator++(int) { return *this; }
};
 
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
 
template <class Container>
inline output_iterator_tag
iterator_category(const front_insert_iterator<Container>&)
{
  return output_iterator_tag();
}
 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
template <class Container>
inline front_insert_iterator<Container> front_inserter(Container& x)
{
  return front_insert_iterator<Container>(x);
}
 
////////////////////////////////////////////////////////////////////////////////
// insert_iterator实现部分
////////////////////////////////////////////////////////////////////////////////
 
template <class Container>
class 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;
 
  insert_iterator(Container& x, typename Container::iterator i)
    : container(&x), iter(i) {}
 
  // 只有提供了insert操作的容器才能使用insert_iterator
  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; }
};
 
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
 
template <class Container>
inline output_iterator_tag
iterator_category(const insert_iterator<Container>&)
{
  return output_iterator_tag();
}
 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
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));
}
 
////////////////////////////////////////////////////////////////////////////////
// reverse_bidirectional_iterator实现部分
////////////////////////////////////////////////////////////////////////////////
 
// reverse_bidirectional_iterator使用的是BidirectionalIterator
// 所以要对operator *(), ++(), ++(int)都提供处理
// 同时因为是反向迭代器, 所以重载运算符的操作要特殊处理
#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class BidirectionalIterator, class T, class Reference = T&,
          class Distance = ptrdiff_t>
#else
template <class BidirectionalIterator, class T, class Reference,
          class Distance>
#endif
class reverse_bidirectional_iterator
{
  typedef reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
                                         Distance> self;
protected:
  BidirectionalIterator current;
public:
  typedef bidirectional_iterator_tag iterator_category;
  typedef T                          value_type;
  typedef Distance                   difference_type;
  typedef T*                         pointer;
  typedef Reference                  reference;
 
  reverse_bidirectional_iterator() {}
  explicit reverse_bidirectional_iterator(BidirectionalIterator x)
    : current(x) {}
  BidirectionalIterator base() const { return current; }
  Reference operator*() const {
    BidirectionalIterator tmp = current;
    return *--tmp;
  }
#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;
  }
};
 
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
 
template <class BidirectionalIterator, class T, class Reference,
          class Distance>
inline bidirectional_iterator_tag
iterator_category(const reverse_bidirectional_iterator<BidirectionalIterator,
                                                       T,
                                                       Reference, Distance>&)
{
  return bidirectional_iterator_tag();
}
 
template <class BidirectionalIterator, class T, class Reference,
          class Distance>
inline T*
value_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
                                               Reference, Distance>&)
{
  return (T*) ;
}
 
template <class BidirectionalIterator, class T, class Reference,
          class Distance>
inline Distance*
distance_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
                                                  Reference, Distance>&)
{
  return (Distance*) ;
}
 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
template <class BidirectionalIterator, class T, class Reference,
          class Distance>
inline bool operator==(
    const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
                                         Distance>& x,
    const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
                                         Distance>& y)
{
  return x.base() == y.base();
}
 
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
 
////////////////////////////////////////////////////////////////////////////////
// reverse_iterator实现部分
////////////////////////////////////////////////////////////////////////////////
 
//  This is the new version of reverse_iterator, as defined in the
//  draft C++ standard.  It relies on the iterator_traits template,
//  which in turn relies on partial specialization.  The class
//  reverse_bidirectional_iterator is no longer part of the draft
//  standard, but it is retained for backward compatibility.
 
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) {}
#ifdef __STL_MEMBER_TEMPLATES
  template <class Iter>
  reverse_iterator(const reverse_iterator<Iter>& x) : current(x.current) {}
#endif /* __STL_MEMBER_TEMPLATES */
 
  iterator_type base() const { return current; }
  reference operator*() const {
    Iterator tmp = current;
    return *--tmp;
  }
#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+(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;
  }
  reference operator[](difference_type n) const { return *(*this + n); }
};
 
template <class Iterator>
inline bool operator==(const reverse_iterator<Iterator>& x,
                       const reverse_iterator<Iterator>& y)
{
  return x.base() == y.base();
}
 
template <class Iterator>
inline bool operator<(const reverse_iterator<Iterator>& x,
                      const reverse_iterator<Iterator>& y)
{
  return y.base() < x.base();
}
 
template <class Iterator>
inline typename reverse_iterator<Iterator>::difference_type
operator-(const reverse_iterator<Iterator>& x,
          const reverse_iterator<Iterator>& y)
{
  return y.base() - x.base();
}
 
template <class Iterator>
inline reverse_iterator<Iterator>
operator+(reverse_iterator<Iterator>::difference_type n,
          const reverse_iterator<Iterator>& x)
{
  return reverse_iterator<Iterator>(x.base() - n);
}
 
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
// 如果不支持partial specialization of class templates(模板类偏特化)
// 则使用HP STL的实现
 
// This is the old version of reverse_iterator, as found in the original
//  HP STL.  It does not use partial specialization.
 
#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class RandomAccessIterator, class T, class Reference = T&,
          class Distance = ptrdiff_t>
#else
template <class RandomAccessIterator, class T, class Reference,
          class Distance>
#endif
class reverse_iterator
{
  typedef reverse_iterator<RandomAccessIterator, T, Reference, Distance>
        self;
protected:
  RandomAccessIterator current;
public:
  typedef random_access_iterator_tag iterator_category;
  typedef T                          value_type;
  typedef Distance                   difference_type;
  typedef T*                         pointer;
  typedef Reference                  reference;
 
  reverse_iterator() {}
  explicit reverse_iterator(RandomAccessIterator x) : current(x) {}
  RandomAccessIterator base() const { return current; }
  Reference operator*() const { return *(current - ); }
#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;
  }
  Reference operator[](Distance n) const { return *(*this + n); }
};
 
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline random_access_iterator_tag
iterator_category(const reverse_iterator<RandomAccessIterator, T,
                                         Reference, Distance>&)
{
  return random_access_iterator_tag();
}
 
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline T* value_type(const reverse_iterator<RandomAccessIterator, T,
                                            Reference, Distance>&)
{
  return (T*) ;
}
 
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline Distance* distance_type(const reverse_iterator<RandomAccessIterator, T,
                                                      Reference, Distance>&)
{
  return (Distance*) ;
}
 
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline bool operator==(const reverse_iterator<RandomAccessIterator, T,
                                              Reference, Distance>& x,
                       const reverse_iterator<RandomAccessIterator, T,
                                              Reference, Distance>& y)
{
  return x.base() == y.base();
}
 
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline bool operator<(const reverse_iterator<RandomAccessIterator, T,
                                             Reference, Distance>& x,
                      const reverse_iterator<RandomAccessIterator, T,
                                             Reference, Distance>& y)
{
  return y.base() < x.base();
}
 
template <class RandomAccessIterator, class T, class Reference, class Distance>
inline Distance operator-(const reverse_iterator<RandomAccessIterator, T,
                                                 Reference, Distance>& x,
                          const reverse_iterator<RandomAccessIterator, T,
                                                 Reference, Distance>& y)
{
  return y.base() - x.base();
}
 
template <class RandomAccessIter, class T, class Ref, class Dist>
inline reverse_iterator<RandomAccessIter, T, Ref, Dist>
operator+(Dist n, const reverse_iterator<RandomAccessIter, T, Ref, Dist>& x)
{
  return reverse_iterator<RandomAccessIter, T, Ref, Dist>(x.base() - n);
}
 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
////////////////////////////////////////////////////////////////////////////////
// istream_iterator实现部分
////////////////////////////////////////////////////////////////////////////////
 
template <class T, class Distance = ptrdiff_t>
class istream_iterator
{
  friend 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() {
    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;
 
  istream_iterator() : stream(&cin), end_marker(false) {}
  istream_iterator(istream& s) : stream(&s) { read(); }
  reference operator*() const { return value; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  istream_iterator<T, Distance>& operator++() {
    read();
    return *this;
  }
  istream_iterator<T, Distance> operator++(int)  {
    istream_iterator<T, Distance> tmp = *this;
    read();
    return tmp;
  }
};
 
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
 
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const istream_iterator<T, Distance>&)
{
  return input_iterator_tag();
}
 
template <class T, class Distance>
inline T* value_type(const istream_iterator<T, Distance>&) { return (T*) ; }
 
template <class T, class Distance>
inline Distance* distance_type(const istream_iterator<T, Distance>&)
{
  return (Distance*) ;
}
 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
template <class T, class Distance>
inline bool operator==(const istream_iterator<T, Distance>& x,
                       const istream_iterator<T, Distance>& y)
{
  return x.stream == y.stream && x.end_marker == y.end_marker ||
         x.end_marker == false && y.end_marker == false;
}
 
////////////////////////////////////////////////////////////////////////////////
// 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_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; }
};
 
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
 
template <class T>
inline output_iterator_tag
iterator_category(const ostream_iterator<T>&)
{
  return output_iterator_tag();
}
 
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
 
__STL_END_NAMESPACE
 
#endif /* __SGI_STL_INTERNAL_ITERATOR_H */
 
// Local Variables:
// mode:C++
// End: