std:: contiguous_iterator
|
Definido en el encabezado
<iterator>
|
||
|
template
<
class
I
>
concept contiguous_iterator
=
|
(desde C++20) | |
El concepto
contiguous_iterator
refina
random_access_iterator
proporcionando la garantía de que los elementos denotados están almacenados de forma contigua en la memoria.
|
Dado un iterador
i
de un tipo que modela
Esto significa que un programa no puede depender de ningún efecto secundario de desreferenciar, incrementar o decrementar un iterador contiguo i , porque las funciones de la biblioteca estándar podrían operar sobre punteros obtenidos mediante std:: to_address ( i ) en lugar de operar directamente sobre i . |
(desde C++26) |
Contenidos |
Determinación del concepto de iterador
La definición de este concepto se especifica mediante un alias de plantilla solo para exposición /*ITER_CONCEPT*/ .
Para determinar /*ITER_CONCEPT*/ < I > , sea ITER_TRAITS < I > igual a I si la especialización std:: iterator_traits < I > se genera desde la plantilla primaria, o std:: iterator_traits < I > en caso contrario:
- Si ITER_TRAITS < I > :: iterator_concept es válido y nombra un tipo, /*ITER_CONCEPT*/ < I > denota el tipo.
- En caso contrario, si ITER_TRAITS < I > :: iterator_category es válido y nombra un tipo, /*ITER_CONCEPT*/ < I > denota el tipo.
-
En caso contrario, si
std::
iterator_traits
<
I
>
se genera desde la plantilla principal,
/*ITER_CONCEPT*/
<
I
>
denota
std::random_access_iterator_tag
.
(Es decir, std:: derived_from < /*ITER_CONCEPT*/ < I > , std:: contiguous_iterator_tag > se asume que es false .) - En caso contrario, /*ITER_CONCEPT*/ < I > no denota un tipo y resulta en un fallo de sustitución.
Requisitos semánticos
Sean
a
y
b
iteradores
dereferenciables
y
c
un iterador no dereferenciable de tipo
I
tal que
b
es
alcanzable
desde
a
y
c
es alcanzable desde
b
, el tipo
I
modela
contiguous_iterator
solo si todos los conceptos que subsume están modelados y se satisfacen todas las siguientes condiciones:
- std:: to_address ( a ) == std:: addressof ( * a ) .
- std:: to_address ( b ) == std:: to_address ( a ) + std:: iter_difference_t < I > ( b - a ) .
- std:: to_address ( c ) == std:: to_address ( a ) + std:: iter_difference_t < I > ( c - a ) .
- std:: to_address ( I { } ) está bien definido.
- ranges:: iter_move ( a ) tiene el mismo tipo, categoría de valor y efectos que std :: move ( * a ) .
- Si ranges:: iter_swap ( a, b ) está bien formado, tiene efectos equivalentes a ranges:: swap ( * a, * b ) .
Preservación de la igualdad
Las expresiones declaradas en las requires expressions de los conceptos de la biblioteca estándar deben ser equality-preserving (excepto cuando se indique lo contrario).
Variaciones de expresión implícita
Una requires expresión que utiliza una expresión que no modifica para algún operando constante lvalue también requiere variaciones de expresión implícitas .
Notas
contiguous_iterator
es modelado por cada tipo de puntero a tipo de objeto completo.
Los tipos de iteradores en la biblioteca estándar que deben cumplir con los requisitos de
LegacyContiguousIterator
en C++17 también deben modelar
contiguous_iterator
en C++20.
Informes de defectos
Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.
| DR | Aplicado a | Comportamiento publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 3607 | C++20 |
contiguous_iterator
podría tener comportamientos personalizados
ranges::iter_move y ranges::iter_swap |
prohibido |
| LWG 4170 | C++20 |
un par de
contiguous_iterator
s inicializados por valor
podría no ser capaz de representar un rango vacío |
garantizado |
Véase también
|
(C++20)
|
especifica que un
bidirectional_iterator
es un iterador de acceso aleatorio, que admite avance en tiempo constante y subíndices
(concepto) |