iterator

此标头是迭代器图书馆。

班

原语

*。

迭代器[医]特性为迭代器%28类模板%29的属性提供了统一的接口。

输入[医]迭代器[医]标签输出[医]迭代器[医]前向[医]迭代器[医]标签双向[医]迭代器[医]标签随机[医]存取[医]迭代器[医]标记空类类型，用于指示迭代器类别%28类%29

迭代器%28在C++17%29基类中被废弃，以简化简单迭代器所需类型的定义%28类模板%29

适配器

倒向[医]用于反向遍历%28类模板%29的迭代器迭代器适配器

移动[医]迭代器%28C++11%29迭代器适配器，该适配器与rvalue引用%28class模板%29脱节

退回去[医]插入[医]迭代器迭代器适配器，用于插入容器%28类模板%29的末尾

前部[医]插入[医]迭代器迭代器适配器，用于插入容器前面的模板%28类模板%29

插入[医]迭代器迭代器适配器插入容器%28类模板%29

流迭代器

iStream[医]从STD：：Basic读取的迭代器输入迭代器[医]iStream%28类模板%29

流[医]迭代器输出迭代器，写入STD：：Basic[医]Ostream%28类模板%29

安布夫[医]从STD：：Basic读取的迭代器输入迭代器[医]流光%28类模板%29

[医]OStreambuf[医]迭代器输出迭代器，写入STD：：Basic[医]流光%28类模板%29

功能

适配器

*。

制造[医]倒向[医]迭代器%28C++14%29创建一个std：：反向[医]从参数%28函数模板%29推断的类型迭代器

制造[医]移动[医]迭代器%28C++11%29创建一个std：：move[医]从参数%28函数模板%29推断的类型迭代器

前部[医]插入器创建STD：：前台[医]插入[医]从参数%28函数模板%29推断的类型迭代器

退回去[医]插入器创建一个std：：back[医]插入[医]从参数%28函数模板%29推断的类型迭代器

插入器创建一个std：：INSERT[医]从参数%28函数模板%29推断的类型迭代器

操作

将迭代器前进给定距离%28功能%29

距离返回两个迭代器之间的距离%28函数%29

下一个%28C++11%29增量迭代器%28功能%29

PRV%28C++11%29减少迭代器%28功能%29

范围

初学者%28C++11%29%28C++14%29返回一个迭代器到容器的开头或数组%28函数%29

endcend%28C++11%29%28C++14%29将迭代器返回到容器的末尾或数组%28函数%29

返回反向迭代器到容器或数组%28函数%29

rendcrend%28C++14%29返回容器的反向迭代器或数组%28功能%29

非会员运算符

运算符==运算符%21=运算符<运算符<=运算符>>=比较底层迭代器%28函数模板%29

运算符+推进迭代器%28函数模板%29

运算符-计算两个迭代器适配器之间的距离%28函数模板%29。

运算符==运算符%21=运算符<运算符<=运算符>>=比较底层迭代器%28函数模板%29

运算符+推进迭代器%28函数模板%29

运算符-计算两个迭代器适配器之间的距离%28函数模板%29。

运算符==运算符%21=比较两个iStream[医]迭代器%28函数模板%29

运算符==运算符%21=比较两个istreambuf[医]迭代器%28函数模板%29

简介

二次

namespace std {
    // primitives:
    template<class Iterator> struct iterator_traits;
    template<class T> struct iterator_traits<T*>;
    template<class Category, class T, class Distance = ptrdiff_t,
    class Pointer = T*, class Reference = T&> struct 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 { };
 
    // iterator operations:
    template <class InputIterator, class Distance>
        void advance(InputIterator& i, Distance n);
    template <class InputIterator>
        typename iterator_traits<InputIterator>::difference_type
        distance(InputIterator first, InputIterator last);
    template <class ForwardIterator>
        ForwardIterator next(ForwardIterator x,
            typename std::iterator_traits<ForwardIterator>::difference_type n = 1);
    template <class BidirectionalIterator>
        BidirectionalIterator prev(BidirectionalIterator x,
            typename std::iterator_traits<BidirectionalIterator>::difference_type n = 1);
 
    // predefined iterators:
    template <class Iterator> class reverse_iterator;
    template <class Iterator1, class Iterator2>
        bool operator==(
            const reverse_iterator<Iterator1>& x,
            const reverse_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator<(
            const reverse_iterator<Iterator1>& x,
            const reverse_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator!=(
            const reverse_iterator<Iterator1>& x,
            const reverse_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator>(
            const reverse_iterator<Iterator1>& x,
            const reverse_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator>=(
            const reverse_iterator<Iterator1>& x,
            const reverse_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator<=(
            const reverse_iterator<Iterator1>& x,
            const reverse_iterator<Iterator2>& y);
 
    template <class Iterator1, class Iterator2>
        auto operator-(
            const reverse_iterator<Iterator1>& x,
            const reverse_iterator<Iterator2>& y) ->decltype(y.base() - x.base());
    template <class Iterator>
        reverse_iterator<Iterator>
        operator+(
            typename reverse_iterator<Iterator>::difference_type n,
            const reverse_iterator<Iterator>& x);
    template <class Iterator>
        reverse_iterator<Iterator> make_reverse_iterator(Iterator i);
 
    template <class Container> class back_insert_iterator;
    template <class Container>
        back_insert_iterator<Container> back_inserter(Container& x);
 
    template <class Container> class front_insert_iterator;
    template <class Container>
        front_insert_iterator<Container> front_inserter(Container& x);
 
    template <class Container> class insert_iterator;
    template <class Container>
        insert_iterator<Container> inserter(Container& x, typename Container::iterator i);
 
    template <class Iterator> class move_iterator;
    template <class Iterator1, class Iterator2>
        bool operator==(
            const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator!=(
            const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator<(
            const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator<=(
            const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator>(
            const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
    template <class Iterator1, class Iterator2>
        bool operator>=(
            const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
 
    template <class Iterator1, class Iterator2>
        auto operator-(
            const move_iterator<Iterator1>& x,
            const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
    template <class Iterator>
        move_iterator<Iterator> operator+(
            typename move_iterator<Iterator>::difference_type n, 
            const move_iterator<Iterator>& x);
    template <class Iterator>
        move_iterator<Iterator> make_move_iterator(Iterator i);
 
    // stream iterators:
    template <class T, class charT = char, class traits = char_traits<charT>,
            class Distance = ptrdiff_t>
        class istream_iterator;
    template <class T, class charT, class traits, class Distance>
        bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
            const istream_iterator<T,charT,traits,Distance>& y);
    template <class T, class charT, class traits, class Distance>
        bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
            const istream_iterator<T,charT,traits,Distance>& y);
 
    template <class T, class charT = char, class traits = char_traits<charT> >
        class ostream_iterator;
 
    template<class charT, class traits = char_traits<charT> >
        class istreambuf_iterator;
    template <class charT, class traits>
        bool operator==(const istreambuf_iterator<charT,traits>& a,
            const istreambuf_iterator<charT,traits>& b);
    template <class charT, class traits>
        bool operator!=(const istreambuf_iterator<charT,traits>& a,
            const istreambuf_iterator<charT,traits>& b);
 
    template <class charT, class traits = char_traits<charT> >
        class ostreambuf_iterator;
 
    // range access:
    template <class C> auto begin(C& c) -> decltype(c.begin());
    template <class C> auto begin(const C& c) -> decltype(c.begin());
    template <class C> auto end(C& c) -> decltype(c.end());
    template <class C> auto end(const C& c) -> decltype(c.end());
    template <class T, size_t N> T* begin(T (&array)[N]);
    template <class T, size_t N> T* end(T (&array)[N]);
}

二次

类`std::iterator_traits`

二次

template<class Iterator> struct iterator_traits {
    typedef typename Iterator::difference_type      difference_type;
    typedef typename Iterator::value_type           value_type;
    typedef typename Iterator::pointer              pointer;
    typedef typename Iterator::reference            reference;
    typedef typename Iterator::iterator_category    iterator_category;
};
 
template<class T> struct iterator_traits<T*> {
    typedef ptrdiff_t                   difference_type;
    typedef T                           value_type;
    typedef T*                          pointer;
    typedef T&                          reference;
    typedef random_access_iterator_tag  iterator_category;
};
 
template<class T> struct iterator_traits<const T*> {
    typedef ptrdiff_t                   difference_type;
    typedef T                           value_type;
    typedef const T*                    pointer;
    typedef const T&                    reference;
    typedef random_access_iterator_tag  iterator_category;
};

二次

类`std::iterator`

二次

template<class Category, class T, class Distance = ptrdiff_t,
         class Pointer = T*, class Reference = T&>
struct iterator {
    typedef T           value_type;
    typedef Distance    difference_type;
    typedef Pointer     pointer;
    typedef Reference   reference;
    typedef Category    iterator_category;
};

二次

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 { };

二次

类`std::reverse_iterator`

二次

template <class Iterator>
class reverse_iterator : public
    iterator<typename iterator_traits<Iterator>::iterator_category,
    typename iterator_traits<Iterator>::value_type,
    typename iterator_traits<Iterator>::difference_type,
    typename iterator_traits<Iterator>::pointer,
    typename iterator_traits<Iterator>::reference> {
public:
    typedef Iterator                                            iterator_type;
    typedef typename iterator_traits<Iterator>::difference_type difference_type;
    typedef typename iterator_traits<Iterator>::reference       reference;
    typedef typename iterator_traits<Iterator>::pointer         pointer;
 
    reverse_iterator();
    explicit reverse_iterator(Iterator x);
    template <class U> reverse_iterator(const reverse_iterator<U>& u);
    template <class U> reverse_iterator& operator=(const reverse_iterator<U>& u);
 
    Iterator base() const; // explicit
    reference operator*() const;
    pointer operator->() const;
 
    reverse_iterator& operator++();
    reverse_iterator  operator++(int);
    reverse_iterator& operator--();
    reverse_iterator  operator--(int);
 
    reverse_iterator  operator+ (difference_type n) const;
    reverse_iterator& operator+=(difference_type n);
    reverse_iterator  operator- (difference_type n) const;
    reverse_iterator& operator-=(difference_type n);
 
    /*unspecified*/ operator[](difference_type n) const;
protected:
    Iterator current;
private:
    Iterator deref_tmp; // exposition only
};

二次

类`std::back_insert_iterator`

二次

template <class Container>
class back_insert_iterator :
    public iterator<output_iterator_tag,void,void,void,void> {
protected:
    Container* container;
public:
    typedef Container container_type;
 
    explicit back_insert_iterator(Container& x);
    back_insert_iterator<Container>&
        operator=(const typename Container::value_type& value);
    back_insert_iterator<Container>&
        operator=(typename Container::value_type&& value);
 
    back_insert_iterator<Container>& operator*();
    back_insert_iterator<Container>& operator++();
    back_insert_iterator<Container>  operator++(int);
};

二次

类`std::front_insert_iterator`

二次

template <class Container>
class front_insert_iterator :
    public iterator<output_iterator_tag,void,void,void,void> {
protected:
    Container* container;
public:
    typedef Container container_type;
 
    explicit front_insert_iterator(Container& x);
    front_insert_iterator<Container>&
    operator=(const typename Container::value_type& value);
    front_insert_iterator<Container>&
    operator=(typename Container::value_type&& value);
 
    front_insert_iterator<Container>& operator*();
    front_insert_iterator<Container>& operator++();
    front_insert_iterator<Container>  operator++(int);
};

二次

类`std::insert_iterator`

二次

template <class Container>
class insert_iterator :
    public iterator<output_iterator_tag,void,void,void,void> {
protected:
    Container*                   container;
    typename Container::iterator iter;
public:
    typedef Container container_type;
 
    insert_iterator(Container& x, typename Container::iterator i);
    insert_iterator<Container>&
    operator=(const typename Container::value_type& value);
    insert_iterator<Container>&
    operator=(typename Container::value_type&& value);
 
    insert_iterator<Container>& operator*();
    insert_iterator<Container>& operator++();
    insert_iterator<Container>& operator++(int);
};

二次

类`std::move_iterator`

二次

template <class Iterator>
class move_iterator {
public:
    typedef Iterator                                            iterator_type;
    typedef typename iterator_traits<Iterator>::difference_type difference_type;
    typedef Iterator                                            pointer;
    typedef typename iterator_traits<Iterator>::value_type      value_type;
    typedef typename iterator_traits<Iterator>::iterator_category
                                                                iterator_category;
    typedef value_type&&                                        reference;
 
    move_iterator();
    explicit move_iterator(Iterator i);
    template <class U> move_iterator(const move_iterator<U>& u);
    template <class U> move_iterator& operator=(const move_iterator<U>& u);
 
    iterator_type base() const;
    reference operator*() const;
    pointer operator->() const;
 
    move_iterator& operator++();
    move_iterator  operator++(int);
    move_iterator& operator--();
    move_iterator  operator--(int);
 
    move_iterator   operator+(difference_type n) const;
    move_iterator&  operator+=(difference_type n);
    move_iterator   operator-(difference_type n) const;
    move_iterator&  operator-=(difference_type n);
    /*unspecified*/ operator[](difference_type n) const;
 
private:
    Iterator current; // exposition only
};

二次

 ? cppreference.com

在CreativeCommonsAttribution下授权-ShareAlike未移植许可v3.0。

http：//en.cppreference.com/w/cpp/Header/iterator

本文档系腾讯云开发者社区成员共同维护，如有问题请联系 cloudcommunity@tencent.com

最后更新于：2017-12-18

班

功能

简介

类std::iterator_traits

类std::iterator

Iterator标签

类std::reverse_iterator

类std::back_insert_iterator

类std::front_insert_iterator

类std::insert_iterator

类std::move_iterator