C++ named requirements: LegacyRandomAccessIterator
A LegacyRandomAccessIterator is a LegacyBidirectionalIterator that can be moved to point to any element in constant time.
If a LegacyRandomAccessIterator it originates from a Container, then it's value_type is the same as the container's, so dereferencing (*it) obtains the container's value_type.
A pointer to an element of an array satisfies all requirements of LegacyRandomAccessIterator.
[edit] Requirements
The type It satisfies LegacyRandomAccessIterator if
- The type
Itsatisfies LegacyBidirectionalIterator
And, given
-
value_type, the type denoted by std::iterator_traits <It>::value_type -
difference_type, the type denoted by std::iterator_traits <It>::difference_type -
reference, the type denoted by std::iterator_traits <It>::reference - i, a, b, objects of type
Itor const It - r, an lvalue of type
It - n, an integer of type
difference_type
The following expressions must be valid and have their specified effects:
| Expression | Return type | Operational semantics | Notes |
|---|---|---|---|
| r += n | It&
|
difference_type m = n; if (m >= 0) while (m--) ++r; |
|
| a + n
n + a |
It
|
It temp = a; return temp += n; |
|
| r -= n | It& |
return r += -n; | The absolute value of n must be within the range of representable values of difference_type.
|
| i - n | It |
It temp = i; return temp -= n; |
|
| b - a | difference_type |
return n; (see the precondition) |
Precondition:
Postcondition:
|
| i[n] | convertible to reference |
*(i + n) | |
| a < b |
meets BooleanTestable (until C++20)models |
Equivalent to return b - a > 0; | Precondition:
Strict total ordering relation:
|
| a > b |
meets BooleanTestable (until C++20)models |
b < a | Total ordering relation opposite to a < b |
| a >= b |
meets BooleanTestable (until C++20)models |
!(a < b) | |
| a <= b |
meets BooleanTestable (until C++20)models |
!(a > b) |
The above rules imply that LegacyRandomAccessIterator also implements LessThanComparable.
A mutable LegacyRandomAccessIterator is a LegacyRandomAccessIterator that additionally satisfies the LegacyOutputIterator requirements.
Concept
For the definition of std::iterator_traits , the following exposition-only concept is defined.
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>>;
where the exposition-only concept __LegacyBidirectionalIterator is described in LegacyBidirectionalIterator.
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 299 (N3066) |
C++98 | the return type of a[n] was required to be convertible to const value_type& |
the return type is required to be convertible to reference
|
| LWG 448 | C++98 | the return type of a[n] was required to be convertible to value_type
|
the return type is required to be convertible to const value_type&[1] |
| LWG 1079 | C++98 | b - a was defined using a < b, resulted in circular definition |
removed a < b from the definition |
| LWG 2114 (P2167R3) |
C++98 | convertibility to bool was too weak to reflect the expectation of implementations | requirements strengthened |
- ↑ LWG issue 299 was reopened after this resolution.
[edit] See also
bidirectional_iterator is a random-access iterator, supporting advancement in constant time and subscripting (concept) [edit]