Requisitos denominados de C++: RandomAccessIterator

De cppreference.com

Un IteradorDeAccesoAleatorioLegado es un BidirectionalIterator que puede moverse para apuntar a cualquier elemento en tiempo constante.

Si un IteradorDeAccesoAleatorioLegado it se origina a partir de un Contenedor, entonces el value_type de it es el mismo que el del contenedor, por lo tanto desreferenciando (*it) se obtiene el value_type del contenedor.

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

Requisitos

El tipo It satisface IteradorDeAccesoAleatorioLegado si

El tipo It satisface IteradorBidireccionalLegado

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 valor de tipo It;
n, un entero de tipo difference_type.

Las siguientes expresiones deben de 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 positiva o negativa
La complejidad es constante (es decir, la implementación de hecho no puede ejecutar el bucle while mostrado en la semántica operacional)

a + n

n + a

It

It temp = a; return temp += n;

n puede ser positiva o negativa
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;
(véase 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 con ComprobableBooleano	(hasta C++20)
Modela `comprobable-booleano`	(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 ComprobableBooleano	(hasta C++20)
Modela `comprobable-booleano`	(desde C++20)

b < a

Relación de ordenamiento total opuesta a a < b

a >= b

Cumple con ComprobableBooleano	(hasta C++20)
Modela `comprobable-booleano`	(desde C++20)

!(a < b)

a <= b

Cumple con ComprobableBooleano	(hasta C++20)
Modela `comprobable-booleano`	(desde C++20)

!(a > b)

Las reglas anteriores implican que IteradorDeAccesoAleatorioLegado también implementa ComparableEnMenorQue.

Un IteradorDeAccesoAleatorioLegado mutable es un IteradorDeAccesoAleatorioLegado que además satisface los requisitos de IteradorDeSalidaLegado.

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 IteradorBidireccionaLegado.

(desde C++20)

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
N3066	C++98	Se requería que el tipo devuelto por `a[n]` fuera convertible a `const value_type&`.	Se requiere que el tipo devuelto sea convertible a `reference`.
LWG 448	C++98	Se requería que el tipo devuelto por `a[n]` fuera convertible a `value_type`.	Se requiere que el tipo devuelto sea convertible a `const value_type&`^[1].
LWG 1079	C++98	`b - a` se definía usando `a < b`, resultado una definición circular.	`a < b` eliminado de la definición.
P2167R3	C++98	La convertibilidad a `bool` era demasiado débil para reflejar la expectativa de las implementaciones.	Se reforzaron los requsitos.

↑ Asunto LWG 299 se reabrió después de esta resolución.

Véase también

Categorías: