C++ named requirements: LegacyRandomAccessIterator

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

C++ named requirements

Basic DefaultConstructible MoveConstructible (C++11) CopyConstructible CopyAssignable MoveAssignable (C++11) Destructible Type properties ScalarType PODType TriviallyCopyable (C++11) TrivialType (C++11) StandardLayoutType (C++11)   ImplicitLifetimeType Library-wide BooleanTestable EqualityComparable LessThanComparable Swappable ValueSwappable (C++11) NullablePointer (C++11) Hash (C++11) Allocator FunctionObject Callable Predicate BinaryPredicate Compare

Container Container ReversibleContainer AllocatorAwareContainer SequenceContainer ContiguousContainer (C++17) AssociativeContainer UnorderedAssociativeContainer (C++11)   Container element DefaultInsertable (C++11) CopyInsertable (C++11) MoveInsertable (C++11) EmplaceConstructible (C++11) Erasable (C++11) Iterator LegacyIterator LegacyInputIterator LegacyOutputIterator LegacyForwardIterator LegacyBidirectionalIterator LegacyRandomAccessIterator LegacyContiguousIterator (C++17) ConstexprIterator (C++20) Stream I/O FormattedInputFunction UnformattedInputFunction FormattedOutputFunction UnformattedOutputFunction Formatters BasicFormatter (C++20) Formatter (C++20)

Random Numbers SeedSequence (C++11) RandomNumberEngine (C++11) RandomNumberDistribution (C++11) UniformRandomBitGenerator (C++11) RandomNumberEngineAdaptor (C++11) Concurrency BasicLockable (C++11) Lockable (C++11) TimedLockable (C++11) SharedLockable (C++14) SharedTimedLockable (C++14) Mutex (C++11) TimedMutex (C++11) SharedMutex (C++17) SharedTimedMutex (C++14) Ranges RangeAdaptorObject (C++20) RangeAdaptorClosureObject (C++20) Multidimensional View LayoutMapping (C++23) LayoutMappingPolicy (C++23) AccessorPolicy (C++23) Other CharTraits RegexTraits (C++11)   BitmaskType LiteralType (C++11) NumericType UnaryTypeTrait (C++11) BinaryTypeTrait (C++11) TransformationTrait (C++11) Clock (C++11) TrivialClock (C++11)

 

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.

Requirements

The type It satisfies LegacyRandomAccessIterator if

• The type It satisfies 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 It or 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; else while (m++) --r; return r;	n can be both positive or negative The complexity is constant (that is, the implementation cannot actually execute the while loop shown in operational semantics)
a + n n + a	It	It temp = a; return temp += n;	n can be both positive or negative a + n == n + a
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: there exists a value n of type difference_type such that a + n == b Postcondition: b == a + (b - a).
i[n]	convertible to reference	*(i + n)
a < b	meets BooleanTestable (until C++20) models boolean-testable (since C++20)	Equivalent to return b - a > 0;	Precondition: same as of b - a Strict total ordering relation: !(a < a) if a < b then !(b < a) if a < b and b < c then a < c a < b or b < a or a == b (exactly one of the expressions is true)
a > b	meets BooleanTestable (until C++20) models boolean-testable (since C++20)	b < a	Total ordering relation opposite to a < b
a >= b	meets BooleanTestable (until C++20) models boolean-testable (since C++20)	!(a < b)
a <= b	meets BooleanTestable (until C++20) models boolean-testable (since C++20)	!(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. 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>>;         }; where the exposition-only concept __LegacyBidirectionalIterator is described in LegacyBidirectionalIterator.

(since C++20)

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&
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

See also

random_access_iterator (C++20)	specifies that a bidirectional_iterator is a random-access iterator, supporting advancement in constant time and subscripting (concept)
Iterator library	provides definitions for iterators, iterator traits, adaptors, and utility functions