《STL源码剖析》-- stl_iterator.h

// Filename:    stl_iterator.h// Comment By:  凝霜// E-mail:      [e-mail]// 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_NAMESPACEStemplate <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_categoryiterator_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*>(0);}template <class Iterator>inline typename iterator_traits<Iterator>::value_type*value_type(const Iterator&){  return static_cast<typename iterator_traits<Iterator>::value_type*>(0);}#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */// 编译器不支持partial specialization of class templates(模板类偏特化)// 需要对所有迭代器类型都提供定义template <class T, class Distance>inline input_iterator_tagiterator_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_tagiterator_category(const forward_iterator<T, Distance>&){  return forward_iterator_tag();}template <class T, class Distance>inline bidirectional_iterator_tagiterator_category(const bidirectional_iterator<T, Distance>&){  return bidirectional_iterator_tag();}template <class T, class Distance>inline random_access_iterator_tagiterator_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*)(0);}template <class T, class Distance>inline T* value_type(const forward_iterator<T, Distance>&){  return (T*)(0);}template <class T, class Distance>inline T* value_type(const bidirectional_iterator<T, Distance>&){  return (T*)(0);}template <class T, class Distance>inline T* value_type(const random_access_iterator<T, Distance>&){  return (T*)(0);}template <class T>inline T* value_type(const T*) { return (T*)(0); }template <class T, class Distance>inline Distance* distance_type(const input_iterator<T, Distance>&){  return (Distance*)(0);}template <class T, class Distance>inline Distance* distance_type(const forward_iterator<T, Distance>&){  return (Distance*)(0);}template <class T, class Distance>inline Distance*distance_type(const bidirectional_iterator<T, Distance>&){  return (Distance*)(0);}template <class T, class Distance>inline Distance*distance_type(const random_access_iterator<T, Distance>&){  return (Distance*)(0);}template <class T>inline ptrdiff_t* distance_type(const T*) { return (ptrdiff_t*)(0); }#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 = 0;  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_typedistance(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#endiftemplate <class BidirectionalIterator, class Distance>inline void __advance(BidirectionalIterator& i, Distance n,                      bidirectional_iterator_tag){  if (n >= 0)    while (n--) ++i;  else    while (n++) --i;}#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)#pragma reset woff 1183#endiftemplate <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_tagiterator_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_SPECIALIZATIONtemplate <class Container>inline output_iterator_tagiterator_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_SPECIALIZATIONtemplate <class Container>inline output_iterator_tagiterator_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_TEMPLATEStemplate <class BidirectionalIterator, class T, class Reference = T&,          class Distance = ptrdiff_t>#elsetemplate <class BidirectionalIterator, class T, class Reference,          class Distance>#endifclass 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_SPECIALIZATIONtemplate <class BidirectionalIterator, class T, class Reference,          class Distance>inline bidirectional_iterator_tagiterator_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*) 0;}template <class BidirectionalIterator, class T, class Reference,          class Distance>inline Distance*distance_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,                                                  Reference, Distance>&){  return (Distance*) 0;}#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_typeoperator-(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_TEMPLATEStemplate <class RandomAccessIterator, class T, class Reference = T&,          class Distance = ptrdiff_t>#elsetemplate <class RandomAccessIterator, class T, class Reference,          class Distance>#endifclass 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 - 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;  }  Reference operator[](Distance n) const { return *(*this + n); }};template <class RandomAccessIterator, class T, class Reference, class Distance>inline random_access_iterator_tagiterator_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*) 0;}template <class RandomAccessIterator, class T, class Reference, class Distance>inline Distance* distance_type(const reverse_iterator<RandomAccessIterator, T,                                                      Reference, Distance>&){  return (Distance*) 0;}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_SPECIALIZATIONtemplate <class T, class Distance>inline input_iterator_tagiterator_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*) 0; }template <class T, class Distance>inline Distance* distance_type(const istream_iterator<T, Distance>&){  return (Distance*) 0;}#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(0) {}  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_SPECIALIZATIONtemplate <class T>inline output_iterator_tagiterator_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: