Namespaces
Variants

    std:: iterator_traits

    From es.cppreference.net
    C++
    Iterator library
    Iterator concepts
    Iterator primitives
    (deprecated in C++17)
    iterator_traits
    (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 Iter >
    struct iterator_traits ;
    template < class T >
    struct iterator_traits < T * > ;
    template < class T >
    struct iterator_traits < const T * > ;
    		(eliminado en C++20)

    std::iterator_traits es la clase de rasgos de tipo que proporciona una interfaz uniforme para las propiedades de los tipos LegacyIterator . Esto hace posible implementar algoritmos únicamente en términos de iteradores.

    La plantilla puede especializarse para iteradores definidos por el usuario de modo que la información sobre el iterador pueda recuperarse incluso si el tipo no proporciona los typedefs habituales.

    Las especializaciones de usuario pueden definir el tipo anidado iterator_concept como una de las etiquetas de categoría de iterador , para indicar conformidad con los conceptos de iterador.

    		(desde C++20)

    Contenidos

    Parámetros de plantilla

    Iter - el tipo de iterador para recuperar propiedades

    Tipos de miembros

    Tipo anidado Definición
    difference_type Iter::difference_type
    value_type Iter::value_type
    pointer Iter::pointer
    reference Iter::reference
    iterator_category Iter::iterator_category


    Si Iter no tiene ninguno de los cinco tipos anidados anteriores, entonces esta plantilla no tiene miembros con esos nombres ( std::iterator_traits es compatible con SFINAE).

    		(desde C++17)
    (hasta C++20)

    Si Iter no tiene pointer , pero tiene los cuatro tipos anidados restantes, entonces estos cuatro tipos anidados se declaran de la siguiente manera:

    Tipo anidado Definición
    difference_type Iter::difference_type
    value_type Iter::value_type
    pointer void
    reference Iter::reference
    iterator_category Iter::iterator_category


    De lo contrario, si Iter satisface el concepto de solo exposición __LegacyInputIterator , los tipos anidados se declaran de la siguiente manera:

    Tipo anidado Definición
    difference_type std:: incrementable_traits < Iter > :: difference_type
    value_type std:: indirectly_readable_traits < Iter > :: value_type
    pointer
    • Iter::pointer si es válido.
    • De lo contrario decltype ( std:: declval < Iter & > ( ) . operator - > ( ) ) si es válido.
    • De lo contrario void .
    reference
    iterator_category


    De lo contrario, si Iter satisface el concepto de solo exposición __LegacyIterator , los tipos anidados se declaran de la siguiente manera:

    Tipo anidado Definición
    difference_type
    value_type void
    pointer void
    reference void
    iterator_category std::output_iterator_tag

    De lo contrario, esta plantilla no tiene miembros con esos nombres ( std::iterator_traits es compatible con SFINAE).

    		(desde C++20)

    Especializaciones

    Este rasgo de tipo puede especializarse para tipos proporcionados por el usuario que pueden utilizarse como iteradores. La biblioteca estándar proporciona especializaciones parciales para tipos de puntero T* , lo que permite utilizar todos los algoritmos basados en iteradores con punteros sin procesar.

    La biblioteca estándar también proporciona especializaciones parciales para algunos adaptadores de iteradores estándar.

    		(desde C++20)

    T* especialización de tipos anidados

    Solo se especializa si std:: is_object_v < T > es true .

    		(since C++20)


    Tipo anidado Definición
    difference_type std::ptrdiff_t
    value_type T (hasta C++20) std:: remove_cv_t < T > (desde C++20)
    pointer T*
    reference T&
    iterator_category std::random_access_iterator_tag
    iterator_concept (desde C++20) std::contiguous_iterator_tag


    const T * tipos anidados de especialización

    Tipo anidado Definición
    difference_type std::ptrdiff_t
    value_type T
    pointer const T *
    reference const T &
    iterator_category std::random_access_iterator_tag
    		(hasta C++20)

    Especializaciones para tipos de biblioteca

    (C++20)
    		proporciona una interfaz uniforme para las propiedades del tipo std::common_iterator
    (especialización de plantilla de clase)
    (C++20)
    		proporciona una interfaz uniforme para las propiedades del tipo std::counted_iterator
    (especialización de plantilla de clase)

    Ejemplo

    Muestra una implementación de propósito general de std:: reverse ( ) para iteradores bidireccionales.

    Ejecutar este código 
    #include <iostream>
#include <iterator>
#include <list>
#include <vector>
template<class BidirIt>
void my_reverse(BidirIt first, BidirIt last)
{
    typename std::iterator_traits<BidirIt>::difference_type n = std::distance(first, last);
    for (--n; n > 0; n -= 2)
    {
        typename std::iterator_traits<BidirIt>::value_type tmp = *first;
        *first++ = *--last;
        *last = tmp;
    }
}
int main()
{
    std::vector<int> v{1, 2, 3, 4, 5};
    my_reverse(v.begin(), v.end());
    for (int n : v)
        std::cout << n << ' ';
    std::cout << '\n';
    std::list<int> l{1, 2, 3, 4, 5};
    my_reverse(l.begin(), l.end());
    for (int n : l)
        std::cout << n << ' ';
    std::cout << '\n';
    int a[]{1, 2, 3, 4, 5};
    my_reverse(a, a + std::size(a));
    for (int n : a)
        std::cout << n << ' ';
    std::cout << '\n';
//  std::istreambuf_iterator<char> i1(std::cin), i2;
//  my_reverse(i1, i2); // compilation error: i1, i2 are input iterators
}

    Salida: 

    5 4 3 2 1
5 4 3 2 1
5 4 3 2 1

    Véase también

    (obsoleto en C++17)
    		clase base para facilitar la definición de tipos requeridos para iteradores simples
    (plantilla de clase)
    (C++20)
    		tipos de clases vacías utilizadas para indicar categorías de iteradores
    (clase)
    (C++20) (C++20) (C++23) (C++20) (C++20) (C++20)
    		calcula los tipos asociados de un iterador
    (plantilla de alias)