[TOC] # 迭代器Adapter > 有些适配器只适用于插入数据,因为iterator_category被置为std::output_iterator_tag只写iterator类型,而且使用back*,需要容器支持push_back操作,使用front*,容器需要支持push_front操作(std::vector<T>不支持)。 # back_insert_iterator ``` template<typename Container> class back_insert_iterator { protected: Container *container; public: typedef std::output_iterator_tag iterator_category; typedef void value_type; typedef void difference_type; typedef void pointer; typedef void reference; explicit back_insert_iterator(Container &c):container(&c){} back_insert_iterator<Container>& operator=(const typename Container::value_type &v) { container->push_back(v); return *this; } public: back_insert_iterator<Container>& operator* () { return *this; } back_insert_iterator<Container>& operator++() { return *this; } back_insert_iterator<Container>& operator++(int) { return *this; } }; template<typename Container> inline back_insert_iterator<Container> back_inserter(Container &c) { return back_insert_iterator<Container>(c); } ``` # front_insert_iterator ``` template<typename Container> class front_insert_iterator { protected: Container *container; public: typedef std::output_iterator_tag iterator_category; typedef void difference_type; typedef void pointer; typedef void reference; typedef void value_type; public: explicit front_insert_iterator(Container &c) :container(&c) {} front_insert_iterator<Container>& operator=(const typename Container::value_type &v) { container->push_front(v); return *this; } public: front_insert_iterator<Container>& operator*() { return *this; } front_insert_iterator<Container>& operator++() { return *this; } front_insert_iterator<Container>& operator++(int) { return *this; } }; template<typename Container> front_insert_iterator<Container> front_insert(Container &c) { return front_insert_iterator<Container>(c); } ``` # insert_iterator ``` template<typename Container> class insert_iterator { protected: Container *container; typename Container::iterator iter; public: typedef std::output_iterator_tag iterator_category; typedef void difference_type; typedef void pointer; typedef void reference; typedef void value_type; public: explicit insert_iterator(Container &c,typename Container::iterator i):container(&c),iter(i){} insert_iterator<Container>& operator=(const typename Container::value_type &v) { iter = container->insert(iter, v); ++iter; //迭代器设计(插入元素后,指向新的元素的位置) return *this; } public: insert_iterator<Container>& operator*() { return *this; } insert_iterator<Container>& operator++() { return *this; } insert_iterator<Container>& operator++(int) { return *this; } }; template<typename Container,typename Iterator> insert_iterator<Container> inserter(Container &x, Iterator i) { typedef Container::iterator iter; return insert_iterator<Container>(x, iter(i)); } ``` # reverse_iterator ``` template<typename Iterator> class reverse_iterator { protected: Iterator current; public: typedef typename std::iterator_traits<Iterator>::value_type value_type; typedef typename std::iterator_traits<Iterator>::difference_type difference_type; typedef typename std::iterator_traits<Iterator>::pointer pointer; typedef typename std::iterator_traits<Iterator>::reference reference; typedef typename std::iterator_traits<Iterator>::iterator_category iterator_category; typedef Iterator iterator_type; typedef reverse_iterator<Iterator> self; public: reverse_iterator() {} explicit reverse_iterator(iterator_type i) :current(i) {} reverse_iterator(const self &s):current(s.current){} reverse_iterator<Iterator> base() { return current; } reference operator*() { Iterator tmp = current; return *--tmp; } pointer operator->() { return &(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; ++(*this); return tmp; } self operator+(difference_type n) { return self(current - n); } self& operator+=(difference_type n) { current -= n; return *this; } self operator-(difference_type n) { return self(current + n); } self& operator-=(difference_type n) { current += n; return *this; } reference operator[](difference_type n) { return *(*this + n); } }; ``` # *iterator测试 ``` void testIteratorAdapter() { std::vector<int> v = { 1,2,3,4 }; std::vector<int> v1 = { 5,6,7,8 }; //std::istream_iterator<int> iiter(std::cin), eos; //std::copy(iiter, eos, std::back_inserter(v)); for_each(v.begin(), v.end(), functor::display<int>()); std::cout << std::endl; //for_each(v.begin(),v.end(),std::) std::copy(v.begin(), v.end(), iterator_adapter::back_inserter(v1)); for_each(v1.begin(), v1.end(), functor::display<int>()); cout << endl; //std::copy(v.begin(), v.end(), iterator_adapter::front_insert(v1)); //std::vecter为连续的数组,push_front需要移动全部数组,没有意义。 for_each(v1.begin(), v1.end(), functor::display<int>()); cout << endl; std::vector<int>::iterator it = std::find(v1.begin(), v1.end(), 5); if (it == v1.end()) cout << endl; std::copy(v.begin(), v.end(), iterator_adapter::inserter(v1,it)); for_each(v1.begin(), v1.end(), functor::display<int>()); cout << endl; std::cout << "reverse iterator:" << std::endl; std::vector<int> v2 = { 1,2,3,4,5,6,7,8,9 }; iterator_adapter::reverse_iterator<std::vector<int>::iterator> b(v2.end()); b[1] = 5; b[3] = 100; *++b = 200; for_each(v2.begin(), v2.end(), functor::display<int>()); } ``` # istream_iterator ``` #define __STL_NULL_TMPL_ARGS template<typename T,typename Distance = ptrdiff_t> class istream_iterator { friend bool operator==__STL_NULL_TMPL_ARGS(const istream_iterator<T, Distance> &x, const istream_iterator &y); protected: std::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 std::input_iterator_tag iterator_category; typedef T value_type; typedef const T* pointer; //由于迭代器类型为input_iterator_tag,所以使用const比较好 typedef const T& reference; typedef Distance difference_type; public: istream_iterator() :stream(&(std::cin)), end_marker(false) { } istream_iterator(std::istream &cin) :stream(&cin) { read(); } reference operator*() { return value; } pointer operator->() { return &(operator*()); } istream_iterator<T, Distance>& operator++() { read(); return *this; } istream_iterator<T,Distance> operator++(int) { istream_iterator<T, Distance>& tmp = *this; read(); return tmp; } }; template<typename T,typename Distance = ptrdiff_t> bool operator==(const istream_iterator<T, Distance> &x, const istream_iterator<T, Distance> &y) { return x->value == y->value; } ``` # ostream_iterator ``` template<typename T, typename Distance = ptrdiff_t> class ostream_iterator { protected: const char* value; std::ostream *stream; public: typedef std::output_iterator_tag iterator_category; typedef void value_type; typedef Distance difference_type; typedef void pointer; typedef void reference; typedef ostream_iterator<T, Distance> self; public: ostream_iterator(std::ostream &cout) :stream(&cout) { ; } ostream_iterator(std::ostream &cout, const char* tip) :stream(&cout), value(tip) { ; } self& operator=(const T &v) { *stream << v; if (value) *stream << value; return *this; } self& operator*() { return *this; } self& operator++() { return *this; } self& operator++(int) { return *this; } }; ```