From cppreference.com
A
is a
that can be moved to point to any element in constant time.
If a
it originates from a
, 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
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 constIt
r, an lvalue of type It
n, an integer of type difference_type
The following expressions must be valid and have their specified effects:
ExpressionReturn typeOperational semanticsNotes r+=nIt&difference_typem=n;if(m>=0)while(m--)++r;elsewhile(m++)--r;returnr;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+nn+a
ItIttemp=a;returntemp+=n;n can be both positive or negative
a+n==n+a
r-=nIt&returnr+=-n;The absolute value of n must be within the range of representable values of difference_type. i-nItIttemp=i;returntemp-=n;b-adifference_typereturnn;
(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<bmeets
(until C++20)models
(since C++20)Equivalent to returnb-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>bmeets
(until C++20)models
(since C++20)b<aTotal ordering relation opposite to a<ba>=bmeets
(until C++20)models
(since C++20)!(a<b)a<=bmeets
(until C++20)models
(since C++20)!(a>b)The above rules imply that LegacyRandomAccessIterator also implements
.
A mutableLegacyRandomAccessIterator is a LegacyRandomAccessIterator that additionally satisfies the
requirements.
Concept
For the definition of
, the following exposition-only concept is defined.
template<classI>concept__LegacyRandomAccessIterator=__LegacyBidirectionalIterator<I>&&std::totally_ordered<I>&&requires(Ii,typenamestd::incrementable_traits<I>::difference_typen){{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
.
(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
(
) C++98 the return type of a[n] was required
to be convertible to constvalue_type&the return type is required to
be convertible to reference
C++98 the return type of a[n] was required
to be convertible to value_typethe return type is required to be
convertible to constvalue_type&
C++98 b-a was defined using a<b,
resulted in circular definition removed a<b from the definition
(
) C++98 convertibility to bool was too weak to reflect the expectation of implementations requirements strengthened
was reopened after this resolution.
See also