std::input_iterator_tag, std::output_iterator_tag, std::forward_iterator_tag, std::bidirectional_iterator_tag, std::random_access_iterator_tag, std::contiguous_iterator_tag

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de iteradores

Conceptos de iteradores
indirectly_readable (C++20) indirectly_writable (C++20) weakly_incrementable (C++20) incrementable (C++20) input_or_output_iterator (C++20) sentinel_for (C++20) sized_sentinel_for (C++20)	input_iterator (C++20) output_iterator (C++20) forward_iterator (C++20) bidirectional_iterator (C++20) random_access_iterator (C++20) contiguous_iterator (C++20)
Primitivas de iteradores
iterator_traits input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20) iterator (en desuso en C++17)	incrementable_traits (C++20) indirectly_readable_traits (C++20) iter_value_titer_difference_titer_reference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++20)(C++20)(C++20)
Conceptos de algoritmos y servicios
Conceptos invocables indirectos
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20) indirect_unary_predicate (C++20)	indirect_binary_predicate (C++20) indirect_equivalence_relation (C++20) indirect_strict_weak_order (C++20)
Requerimientos comunes de algoritmos
indirectly_movable (C++20) indirectly_movable_storable (C++20) indirectly_copyable (C++20) indirectly_copyable_storable (C++20)	indirectly_swappable (C++20) indirectly_comparable (C++20) permutable (C++20) mergeable (C++20) sortable (C++20)
Servicios
indirect_result_t	projected
Adaptadores de iteradores
reverse_iterator move_iterator (C++11) move_sentinel (C++20) common_iterator (C++20) counted_iterator (C++20) back_insert_iterator front_insert_iterator insert_iterator	make_reverse_iterator (C++14) make_move_iterator (C++11) default_sentinel_tdefault_sentinel (C++20)(C++20) unreachable_sentinel_tunreachable_sentinel (C++20)(C++20) back_inserter front_inserter inserter
Iteradores de flujos
istream_iterator ostream_iterator	istreambuf_iterator ostreambuf_iterator
Puntos de personalización de iteradores
ranges::iter_move (C++20)
ranges::iter_swap (C++20)
Operaciones de iteradores
advance distance prev (C++11) next (C++11)	ranges::advance (C++20) ranges::distance (C++20) ranges::prev (C++20) ranges::next (C++20)
Acceso a rangos
begincbegin (C++11)(C++14) endcend (C++11)(C++14) sizessize (C++17)(C++20)	rbegincrbegin (C++14)(C++14) rendcrend (C++14)(C++14) empty (C++17) data (C++17)

 

<tbody> </tbody>

Definido en el archivo de encabezado <iterator>
struct input_iterator_tag {};	(1)
struct output_iterator_tag {};	(2)
struct forward_iterator_tag : public input_iterator_tag {};	(3)
struct bidirectional_iterator_tag : public forward_iterator_tag {};	(4)
struct random_access_iterator_tag : public bidirectional_iterator_tag {};	(5)
struct contiguous_iterator_tag : public random_access_iterator_tag {};	(6)	(desde C++20)

See More

Define la categoría de un iterador. Cada etiqueta es un tipo vacío.

Categoría de iterador

Para cada tipo It de IteradorLegado, se debe definir un typedef std::iterator_traits<It>::iterator_category que sea un alias de uno de estos tipos de etiqueta, para indicar la categoría más específica en la que se encuentra It.

1. input_iterator_tag corresponde a IteradorDeEntradaLegado.
2. output_iterator_tag corresponde a IteradorDeSalidaLegado.
3. forward_iterator_tag corresponde a IteradorDeAvanceLegado.
4. bidirectional_iterator_tag corresponde a IteradorBidireccionalLegado.
5. random_access_iterator_tag corresponde a IteradorDeAccesoAleatorioLegado.

Las etiquetas de categoría de iterador contienen información que se puede utilizar para seleccionar los algoritmos más eficientes para el conjunto de requisitos específicos implícitos en la categoría.

Concepto de iterador Para cada input_iterator de tipo It, se puede declarar It::iterator_concept (si std::iterator_traits<It> se genera a partir de la plantilla principal) o std::iterator_traits<It>::iterator_concept (si std::iterator_traits<It> está especializado) como un alias para una de estas etiquetas, para indicar el concepto de iterador más sólido que It pretende modelar. input_iterator_tag corresponde a input_iterator. forward_iterator_tag corresponde a forward_iterator. bidirectional_iterator_tag corresponde a bidirectional_iterator. random_access_iterator_tag corresponde a random_access_iterator. contiguous_iterator_tag corresponde a contiguous_iterator. Si no se proporciona iterator_concept, se utiliza iterator_category como alternativa. Si tampoco se proporciona iterator_category (es decir, It no es un Iterator) y std::iterator_traits<It> no está especializado, se supone random_access_iterator_tag. En cualquier caso, no se satisface ningún concepto si no se admiten las operaciones requeridas, independientemente de la etiqueta.

(desde C++20)

Notas

No existe una etiqueta independiente para IteradorContiguoLegado. Es decir, no es posible identificar un IteradorContiguoLegado en función de su iterator_category. Para definir un algoritmo especializado para iteradores contiguos, utiliza el concepto contiguous_iterator. (desde C++20)

No existen correspondencias entre output_iterator_tag y el concepto output_iterator. Establecer iterator_concept en output_iterator_tag solo indica que el tipo no modela input_iterator.

Ejemplo

La técnica común para la selección de algoritmos basada en etiquetas de categoría de iterador es utilizar una función despachadora (la alternativa es std::enable_if). Las clases de etiqueta de iterador también se utilizan en las definiciones de conceptos correspondientes para indicar los requisitos, que no se pueden expresar solo en términos de patrones de uso. (desde C++20)

Ejecuta este código

#include <iostream>
#include <iterator>
#include <list>
#include <vector>

// Usando conceptos (comprobación de etiqueta es parte de los mismos conceptos)

template<std::bidirectional_iterator BDIter>
void alg(BDIter, BDIter)
{
    std::cout << "1. alg() \t llamado para iterador bidireccional\n";
}

template<std::random_access_iterator RAIter>
void alg(RAIter, RAIter)
{
    std::cout << "2. alg() \t llamado para iterador de acceso aleatorio\n";
}

// Legado, usando despacho de etiqueta

namespace legado
{
    // Muy a menudo, los detalles de implementación están ocultos en un
    // espacio de nombres dedicado.
    namespace detalles
    {
        template<class BDIter>
        void alg(BDIter, BDIter, std::bidirectional_iterator_tag)
        {
            std::cout << "3. legado::alg() llamado para iterador bidireccional\n";
        }

        template<class RAIter>
        void alg(RAIter, RAIter, std::random_access_iterator_tag)
        {
            std::cout << "4. legado::alg() llamado para iterador de acceso aleatorio\n";
        }
    } // namespace detalles

    template<class Iter>
    void alg(Iter first, Iter last)
    {
        detalles::alg(first, last,
            typename std::iterator_traits<Iter>::iterator_category());
    }
} // namespace legado

int main()
{
    std::list<int> l;
    alg(l.begin(), l.end()); // 1.
    legado::alg(l.begin(), l.end()); // 3.

    std::vector<int> v;
    alg(v.begin(), v.end()); // 2.
    legado::alg(v.begin(), v.end()); // 4.

//  std::istreambuf_iterator<char> i1(std::cin), i2;
//  alg(i1, i2);         // Error de compilación: 
                         //no hay ninguna función coincidente para la llamada
//  legado::alg(i1, i2); // Error de compilación:
                         //no hay ninguna función coincidente para la llamada
}

Salida:

1. alg() 	 llamado para iterador bidireccional
3. legado::alg() llamado para iterador bidireccional
2. alg() 	 llamado para iterador de acceso aleatorio
4. legado::alg() llamado para iterador de acceso aleatorio

Véase también

iterator	El iterador básico. (plantilla de clase)
iterator_traits	Proporciona una interfaz uniforme para las propiedades de un iterador. (plantilla de clase)