RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../string/../named_req/RandomAccessIterator.html below:

C++ named requirements: LegacyRandomAccessIterator - cppreference.com

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

[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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4