Biblioteca de iteradores
De cppreference.com
< cpp
La biblioteca de iteradores proporciona definiciones para cinco (hasta C++17)seis (desde C++17) tipos de iteradores así como rasgos de iteradores, adaptadores y funciones de servicio.
[editar] Categorías de iteradores
Hay cinco (hasta C++17)seis (desde C++17) tipos de iteradores: InputIterator, OutputIterator, ForwardIterator, BidirectionalIterator, RandomAccessIterator, y ContiguousIterator (desde C++17).
En lugar de estar definido por tipos específicos, cada categoría de iterador está definida por las operaciones que se pueden realizar en él. Esta definición significa que cualquier tipo que admita las operaciones necesarias se puede usar como un iterador; por ejemplo, un puntero admite todas las operaciones requeridas por RandomAccessIterator, por lo que un puntero se puede usar en cualquier lugar en que se espera un RandomAccessIterator.
Todas las categorías de iterador (excepto OutputIterator) se pueden organizar en una jerarquía, donde las categorías de iterador más potentes (p. ej., RandomAccessIterator) admiten las operaciones de categorías menos potentes (p. ej., InputIterator). Si un iterador cae en una de estas categorías y también satisface los requisitos de OutputIterator, se llama iterador mutable y soporta tanto la entrada como la salida. Los iteradores no mutables se denominan iteradores constantes.
| Categoría de iterador | Operaciones definidas | ||||
|---|---|---|---|---|---|
| ContiguousIterator | RandomAccessIterator | BidirectionalIterator | ForwardIterator | InputIterator |
|
| |||||
| |||||
| |||||
| |||||
|
Los iteradores que caen en una de las categorías anteriores y que también cumplen los requisitos de OutputIterator se denominan iteradores mutables. | |||||
| OutputIterator |
| ||||
Nota: La categoría ContiguousIterator se especificó formalmente en C++17, pero los iteradores de std::vector, std::basic_string, std::array, y std::valarray, así como los punteros a arrays de C frecuentemente se tratan como una categoría separada en codigo que antecede a C++17.
[editar] Conceptos de iteradores de C++20
C++20 introduce un nuevo sistema de iteradores basado en conceptos que son diferentes de los iteradores de C++17. Si bien la taxonomía básica sigue siendo similar, los requisitos para las categorías de iteradores individuales son algo diferentes.
| Definido en el espacio de nombres
std | |
| Especifica que un tipo puede leerse indirectamente al aplicar el operador *. (concepto) | |
| Especifica que un valor puede escribirse al objeto referenciado por un iterador. (concepto) | |
Especifica que un tipo [[cpp/concepto no reconocido/Semiregular|Semiregular]] puede incrementarse con operadores de preincremento y posincremento. (concepto) | |
Especifica que la operación de incremento en un tipo weakly_incrementable es conservadora de igualdad y que el tipo es equality_comparable. (concepto) | |
| Especifica que los objetos de un tipo pueden incrementarse y desreferenciarse. (concepto) | |
Especifica que un tipo es un centinela para un tipo input_or_output_iterator. (concepto) | |
| Especifica que el operador aditivo de substracción - puede aplicarse a un iterador y un centinela para calcular su diferencia en tiempo constante. (concepto) | |
| Especifica que un tipo es un iterador de entrada. Es decir, sus valores referenciados pueden leerse y ser tanto preincrementados como posincrementados. (concepto) | |
| Especifica que un tipo es un iterador de salida para un tipo de valor dado. Es decir, los valores de ese tipo pueden ser escritos y pueden ser tanto preincrementados como posincrementados. (concepto) | |
| (C++20) |
Especifica que un input_iterator es un iterador de avance, que admite la comparación de igualdad y múltiples pasadas. (concepto) |
Especifica que un forward_iterator es un iterador bidireccional que puede retroceder. (concepto) | |
| (C++20) |
Especifica que un bidirectional_iterator es un iterador de acceso aleatorio, que admite el avance en tiempo constante y acceso de subíndice. (concepto) |
Especifica que un random_access_iterator es un iterador contiguo, refiriéndose a los elementos que se encuentran contiguos en memoria. (concepto) | |
[editar] Tipos asociados con iteradores
| Definido en el espacio de nombres
std | |
Calcula el tipo diferencia de un tipo weakly_incrementable. (plantilla de clase) | |
Calcula el tipo del valor de un tipo indirectly_readable. (plantilla de clase) | |
| Calcula los tipos asociados de un iterador. (plantilla de alias) | |
[editar] Operaciones rudimentarias de iteradores
| Proporciona una interfaz uniforme para las propiedades de un iterador. (plantilla de clase) | |
| Tipos clase vacíos para indicar categorías de iteradores. (clase) | |
| El iterador básico. (plantilla de clase) |
[editar] Puntos de personalización de iteradores
| Definido en el espacio de nombres
std::ranges | |
| Convierte el resultado de desreferenciar un objeto a su tipo asociado de referencia rvalue. (objeto punto de personalización) | |
| (C++20) |
Intercambia los valores referenciados por dos objetos desreferenciables. (objeto punto de personalización) |
[editar] Conceptos de algoritmos y servicios
C++20 también proporciona un conjunto de conceptos y plantillas de servicio relacionadas diseñadas para facilitar la restricción de las operaciones de algoritmos comunes.
| Definido en el archivo de encabezado
<iterator> | |
| Definido en el espacio de nombres
std | |
Conceptos que pueden invocarse indirectamente | |
Especifica que se puede invocar un tipo invocable con el resultado de eliminar la referencia a un tipo indirectly_readable. (concepto) | |
| (C++20) |
Especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar un tipo indirectly_readable, satisface a predicate (concepto) |
| (C++20) |
Especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar dos tipos indirectly_readable, satisface a predicate (concepto) |
Especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar dos tipos indirectly_readable, satisface a equivalence_relation (concepto) | |
| (C++20) |
Especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar dos tipos indirectly_readable, satisface a strict_weak_order (concepto) |
Requerimientos comunes de algoritmos | |
| (C++20) |
Especifica que pueden moverse valores de un tipo indirectly_readable a un tipo indirectly_writable (concepto) |
| (C++20) |
Especifica que pueden moverse valores de un tipo indirectly_readable a un tipo indirectly_writable y que el movimiento puede llevarse a cabo mediante un objeto intermedio (concepto) |
| (C++20) |
Especifica que pueden copiarse valores de un tipo indirectly_readable a un tipo indirectly_writable (concepto) |
| (C++20) |
Especifica que pueden copiarse valores de un tipo indirectly_readable a un tipo indirectly_writable y que la copia puede llevarse a cabo mediante un objeto intermedio (concepto) |
| (C++20) |
Especifica que los valores referenciados por dos tipos indirectly_readable pueden intercambiarse (concepto) |
| (C++20) |
Especifica que los valores referenciados por dos tipos indirectly_readable pueden compararse (concepto) |
| (C++20) |
Especifica los requerimientos comunes de los algoritmos que reordenan elementos en su lugar (concepto) |
| (C++20) |
Especifica los requerimientos de los algoritmos que fusionan secuencias ordenadas en una secuencia de salida copiando elementos (concepto) |
| (C++20) |
Especifica los requerimientos comunes de los algoritmos que permutan secuencias en secuencias ordenadas (concepto) |
Servicios | |
| (C++20) |
Calcula el resultado de invocar un tipo invocable sobre el resultado de desreferenciar algún conjunto de tipos indirectly_readable (plantilla de alias) |
| (C++20) |
Plantilla asistente para especificar las restricciones de algoritmos que aceptan proyecciones (plantilla de clase) |
[editar] Adaptadores de iteradores
| Adaptador de iterador para recorrido en orden inverso. (plantilla de clase) | |
| (C++14) |
Crea un std::reverse_iterator del tipo inferido a partir del argumento. (plantilla de función) |
| (C++11) |
Adaptador de iterador que se desreferencia a una referencia rvalue. (plantilla de clase) |
| (C++20) |
Adaptador de centinela para uso con std::move_iterator (plantilla de clase) |
| (C++11) |
Crea un std::move_iterator del tipo inferido a partir del argumento. (plantilla de función) |
| (C++20) |
Adapta un tipo de iterador y su centinela a un tipo de iterador común. (plantilla de clase) |
| (C++20) |
Centinela por defecto para uso con iteradores que conocen el límite de su rango. (clase) |
| (C++20) |
Adaptador de iterador que rastrea la distancia hasta el final del rango. (plantilla de clase) |
| (C++20) |
Centinela que siempre se compara desigual a cualquier tipo [[cpp/concepto no reconocido/WeaklyIncrementable|WeaklyIncrementable]]. (clase) |
| Adaptador de iterador para la inserción al final de un contenedor. (plantilla de clase) | |
| Crea un std::back_insert_iterator de tipo inferido a partir del argumento. (plantilla de función) | |
| Adaptador de iterador para la inserción en la parte frontal de un contenedor. (plantilla de clase) | |
| Crea un std::front_insert_iterator de tipo inferido a partir del argumento. (plantilla de función) | |
| Adaptador de iterador para la inserción en un contenedor. (plantilla de clase) | |
| Crea un std::insert_iterator de tipo inferido a partir del argumento. (plantilla de función) |
[editar] Iteradores de flujos
| Iterador de entrada que lee de un flujo de entrada (std::basic_istream). (plantilla de clase) | |
| Iterador de salida que escribe a un flujo de salida (std::basic_ostream). (plantilla de clase) | |
| Iterador de entrada que lee de un búfer de flujo (std::basic_streambuf). (plantilla de clase) | |
| Iterador de salida que escribe a un búfer de flujo (std::basic_streambuf). (plantilla de clase) |
[editar] Operaciones de iteradores
| Definido en el archivo de encabezado
<iterator> | |
| Avanza un iterador en una distancia determinada. (función) | |
| Devuelve la distancia entre dos iteradores. (función) | |
| (C++11) |
Incrementa un iterador. (función) |
| (C++11) |
Decrementa un iterador. (función) |
| (C++20) |
Avanza un iterador en una distancia dada o a un límite dado. (niebloid) |
| (C++20) |
Devuelve la distancia entre un iterador y un centinela, o entre el principio y el fin de un rango. (niebloid) |
| (C++20) |
Incrementa un iterador en una distancia dada o a un límite. (niebloid) |
| (C++20) |
Decrementa un iterador en una distancia dada o a un límite. (niebloid) |
[editar] Acceso a rangos
Estas funciones no miembro proporcionan una interfaz genérica para contenedores, arrays simples e std::initializer_list.| Definido en el archivo de encabezado
<array> | |
| Definido en el archivo de encabezado
<deque> | |
| Definido en el archivo de encabezado
<forward_list> | |
| Definido en el archivo de encabezado
<iterator> | |
| Definido en el archivo de encabezado
<list> | |
| Definido en el archivo de encabezado
<map> | |
| Definido en el archivo de encabezado
<regex> | |
| Definido en el archivo de encabezado
<set> | |
| Definido en el archivo de encabezado
<span> | |
| Definido en el archivo de encabezado
<string> | |
| Definido en el archivo de encabezado
<string_view> | |
| Definido en el archivo de encabezado
<unordered_map> | |
| Definido en el archivo de encabezado
<unordered_set> | |
| Definido en el archivo de encabezado
<vector> | |
| Definido en el espacio de nombres
std | |
| (C++11)(C++14) |
Devuelve un iterator al comienzo de un contenedor o array. (plantilla de función) |
| (C++11)(C++14) |
Devuelve un iterator al final de un contenedor o array (plantilla de función) |
| (C++14) |
Devuelve un iterador inverso al contenedor o array (plantilla de función) |
| (C++14) |
Devuelve un iterador inverso al final para un contenedor o array (plantilla de función) |
| (C++17)(C++20) |
Devuelve el tamaño de un contenedor o un array. (plantilla de función) |
| (C++17) |
Comprueba si un contenedor está vacío (plantilla de función) |
| (C++17) |
Obtiene el puntero al array subyacente. (plantilla de función) |
