Namespaces
Variants

    std:: iterator

    From es.cppreference.net
    C++
    Iterator library
    Iterator concepts
    Iterator primitives
    iterator
    (deprecated in C++17)
    (C++20)
    (C++20)


    Algorithm concepts and utilities
    Indirect callable concepts
    Common algorithm requirements
    (C++20)
    (C++20)
    (C++20)
    Utilities
    (C++20)
    Iterator adaptors
    Range access
    (C++11) (C++14)
    (C++14) (C++14)
    (C++11) (C++14)
    (C++14) (C++14)
    (C++17) (C++20)
    (C++17)
    (C++17)
    Definido en el encabezado <iterator>
    template <

    class Category,
    class T,
    class Distance = std:: ptrdiff_t ,
    class Pointer = T * ,
    class Reference = T &

    > struct iterator ;
    		(obsoleto en C++17)

    std::iterator es la clase base proporcionada para simplificar las definiciones de los tipos requeridos para los iteradores.

    Contenidos

    Parámetros de plantilla

    Categoría - la categoría del iterador. Debe ser una de las etiquetas de categoría de iterador .
    T - el tipo de los valores que pueden obtenerse al desreferenciar el iterador. Este tipo debe ser void para iteradores de salida.
    Distance - un tipo que puede utilizarse para identificar la distancia entre iteradores
    Pointer - define un puntero al tipo sobre el que se itera ( T )
    Reference - define una referencia al tipo sobre el que se itera ( T )

    Tipos de miembros

    Tipo de miembro Definición
    iterator_category Category
    value_type T
    difference_type Distance
    pointer Pointer
    reference Reference

    Ejemplo

    El siguiente ejemplo muestra cómo implementar un input iterator heredando de std::iterator

    Ejecutar este código 
    #include <algorithm>
#include <iostream>
template<long FROM, long TO>
class Range
{
public:
    // member typedefs provided through inheriting from std::iterator
    class iterator : public std::iterator<
                                std::input_iterator_tag, // iterator_category
                                long,                    // value_type
                                long,                    // difference_type
                                const long*,             // pointer
                                long                     // reference
                            > {
        long num = FROM;
    public:
        explicit iterator(long _num = 0) : num(_num) {}
        iterator& operator++() { num = TO >= FROM ? num + 1: num - 1; return *this; }
        iterator operator++(int) { iterator retval = *this; ++(*this); return retval; }
        bool operator==(iterator other) const { return num == other.num; }
        bool operator!=(iterator other) const { return !(*this == other); }
        reference operator*() const { return num; }
    };
    iterator begin() { return iterator(FROM); }
    iterator end() { return iterator(TO >= FROM? TO + 1 : TO - 1); }
};
int main()
{
    // std::find requires an input iterator
    auto range = Range<15, 25>();
    auto itr = std::find(range.begin(), range.end(), 18);
    std::cout << *itr << '\n'; // 18
    // Range::iterator also satisfies range-based for requirements
    for (long l : Range<3, 5>())
        std::cout << l << ' '; // 3 4 5
    std::cout << '\n';
}

    Salida: 

    18
3 4 5

    Véase también

    		proporciona una interfaz uniforme para las propiedades de un iterador
    (plantilla de clase)
    (C++20)
    		tipos de clases vacías utilizados para indicar categorías de iteradores
    (clase)