Namespaces
Variants

C++ named requirements: LegacyRandomAccessIterator

From cppreference.net
C++
C++ named requirements

Un LegacyRandomAccessIterator es un LegacyBidirectionalIterator que puede moverse para apuntar a cualquier elemento en tiempo constante.

Si un LegacyRandomAccessIterator it proviene de un Container , entonces el value_type de it es el mismo que el del contenedor, por lo que desreferenciar ( * it ) obtiene el value_type del contenedor.

Un puntero a un elemento de un array satisface todos los requisitos de LegacyRandomAccessIterator .

Contenidos

Requisitos

El tipo It satisface LegacyRandomAccessIterator si

Y, dado

  • value_type , el tipo denotado por std:: iterator_traits < It > :: value_type
  • difference_type , el tipo denotado por std:: iterator_traits < It > :: difference_type
  • reference , el tipo denotado por std:: iterator_traits < It > :: reference
  • i , a , b , objetos de tipo It o const It
  • r , un lvalue de tipo It
  • n , un entero de tipo difference_type

Las siguientes expresiones deben ser válidas y tener sus efectos especificados:

Expresión Tipo de retorno Semántica operacional Notas
r + = n It& difference_type m = n ;

if ( m >= 0 ) while ( m -- ) ++ r ;
else while ( m ++ ) -- r ;
return r ;

  • n puede ser tanto positivo como negativo
  • La complejidad es constante (es decir, la implementación no puede ejecutar realmente el bucle while mostrado en la semántica operacional)
a + n

n + a

It It temp = a ;

return temp + = n ;

  • n puede ser tanto positivo como negativo
  • a + n == n + a
r - = n It& return r + = - n ; El valor absoluto de n debe estar dentro del rango de valores representables de difference_type .
i - n It It temp = i ;
return temp - = n ;
b - a difference_type return n ;
(ver la precondición)

Precondición:

  • existe un valor n de tipo difference_type tal que a + n == b

Poscondición:

  • b == a + ( b - a ) .
i [ n ] convertible a reference * ( i + n )
a < b

cumple BooleanTestable

(hasta C++20)

modela boolean-testable

(desde C++20)
Equivalente a return b - a > 0 ; Precondición:
  • igual que b - a

Relación de orden total estricto:

  • ! ( a < a )
  • si a < b entonces ! ( b < a )
  • si a < b y b < c entonces a < c
  • a < b o b < a o a == b
    (exactamente una de las expresiones es verdadera)
a > b

cumple con BooleanTestable

(hasta C++20)

modela boolean-testable

(desde C++20)
b < a Relación de orden total opuesta a a < b
a >= b

cumple BooleanTestable

(hasta C++20)

modela boolean-testable

(desde C++20)
! ( a < b )
a <= b

cumple con BooleanTestable

(hasta C++20)

modela boolean-testable

(desde C++20)
! ( a > b )

Las reglas anteriores implican que LegacyRandomAccessIterator también implementa LessThanComparable .

Un mutable LegacyRandomAccessIterator es un LegacyRandomAccessIterator que adicionalmente satisface los requisitos de LegacyOutputIterator .

Concepto

Para la definición de std::iterator_traits , se define el siguiente concepto solo para exposición.

template < class I >

concept __LegacyRandomAccessIterator =
__LegacyBidirectionalIterator < I > && std:: totally_ordered < I > &&
requires ( I i, typename std:: incrementable_traits < I > :: difference_type n )
{
{ i + = n } - > std:: same_as < I & > ;
{ i - = n } - > std:: same_as < I & > ;
{ i + n } - > std:: same_as < I > ;
{ n + i } - > std:: same_as < I > ;
{ i - n } - > std:: same_as < I > ;
{ i - i } - > std:: same_as < decltype ( n ) > ;
{ i [ n ] } - > std:: convertible_to < std:: iter_reference_t < I >> ;

} ;

donde el concepto solo para exposición __LegacyBidirectionalIterator se describe en LegacyBidirectionalIterator .

(desde 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 299
( N3066 ) 		C++98 el tipo de retorno de a [ n ] era requerido
ser convertible a const value_type & 		el tipo de retorno debe
ser convertible a reference
LWG 448 C++98 el tipo de retorno de a [ n ] era requerido
ser convertible a value_type 		el tipo de retorno debe ser
convertible a const value_type & [1]
LWG 1079 C++98 b - a estaba definido usando a < b ,
resultaba en definición circular 		eliminado a < b de la definición
LWG 2114
( P2167R3 ) 		C++98 la convertibilidad a bool era demasiado débil para reflejar las expectativas de las implementaciones requisitos fortalecidos
  1. ↑ LWG issue 299 se reabrió después de esta resolución.

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)
Biblioteca de iteradores proporciona definiciones para iteradores, rasgos de iteradores, adaptadores y funciones de utilidad