std::contiguous_iterator

 

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)

 

Definido en el archivo de encabezado <iterator>
template<class I>   concept contiguous_iterator =     std::random_access_iterator<I>&&     std::derived_from</*CONCEPTO_ITER*/<I>, std::contiguous_iterator_tag>&&     std::is_lvalue_reference_v<std::iter_reference_t<I>>&&     std::same_as<       std::iter_value_t<I>, std::remove_cvref_t<std::iter_reference_t<I>>     >&&     requires(const I& i){       {std::to_address(i)}->         std::same_as<std::add_pointer_t<std::iter_reference_t<I>>>;     };		(desde C++20)

El concepto contiguous_iterator es un refinamiento de random_access_iterator que proporciona una garantía que los elementos denotados se almacenan de manera contigua en la memoria.

Determinación del concepto de iterador

La definición de este concepto se especifica mediante una plantilla de alias de solo exposición /*CONCEPTO_ITER*/.

Para determinar /*CONCEPTO_ITER*/<I>, dejemos que RASGOS_ITER<I> denote I si la especialización std::iterator_traits<I> se genera a partir de la plantilla principal, o std::iterator_traits<I> de lo contrario:

• Si RASGOS_ITER<I>::iterator_concept es válido y nombra un tipo, /*CONCEPTO_ITER*/<I> denota el tipo.
• De lo contrario, si RASGOS_ITER<I>::iterator_category es válido y nombra un tipo, /*CONCEPTO_ITER*/<I> denota el tipo.
• De lo contrario, si std::iterator_traits<I> se genera a partir de la plantilla principal, /*CONCEPTO_ITER*/<I> denota std::random_access_iterator_tag.
• De lo contrario, /*CONCEPTO_ITER*/<I> no denota un tipo y da como resultado un error de sustitución.

Requerimientos semánticos

Sean a y b iteradores desreferenciables y c sea un iterador no desreferenciable de tipo I tal que b puede alcanzarse desde a y c es puede alcanzarse desde b. El tipo I modela contiguous_iterator solo si todos los conceptos que subsume se modelan, y:

• std::to_address(a)==std::addressof(*a),
• std::to_address(b)==std::to_address(a)+std::iter_difference_t<I>(b - a), y
• std::to_address(c)==std::to_address(a)+std::iter_difference_t<I>(c - a).

Conservación de la igualdad

Una expresión es conservadora de igualdad si resulta en salidas iguales dadas entradas iguales.

• Las entradas de una expresión consisten en sus operandos.
• Las salidas de una expresión consisten en su resultado y todos los operandos modificados por la expresión (si es que los hay).

Cada expresión que se requiere sea conservadora de igualdad, se requiere además que sea estable: dos evaluaciones de tal expresión con los mismos objetos de entrada debe tener salidas iguales si no se encuentra alguna modificación interventora de esos objetos de entrada.

A menos que se indique de otra manera, cada expresión utilizada en una expresión-requiere se requiere sea conservadora de igualdad y estable, y la evaluación de la expresión puede solamente modificar sus operandos no constantes. Los operandos que son constantes no deben ser modificados.

Variaciones de expresión implícita

Una expresión-requiere que usa una expresión que no es modificable para algún operando l-valor constante también requiere implícitamente variaciones adicionales de esa expresión que acepten un l-valor no constante o un r-valor (posiblemente constante) para el operando dado, a menos que tal variación de expresión se requiera explícitamente con semánticas discrepantes. Estas variaciones de expresión implícita deben cumplir con los mismos requerimientos semánticos de la expresión declarada. No se especifica hasta qué punto una implementación valida la sintaxis de las variaciones.

Notas

contiguous_iterator se modela por todo tipo puntero a un tipo objeto completo.

A los tipos iterador en la biblioteca estándar que se les requiere que satisfagan los requerimientos de ContiguousIterator en C++17 también se les requiere que modelen contiguous_iterator en C++20.

Véase también

random_access_iterator (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)