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*>(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_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*)(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_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 >= 0) 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*) 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_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 - 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_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*) 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_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*) 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_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:
posted on 2015-11-23 11:26 zyz913614263 阅读(314) 评论(0) 编辑 收藏 举报
