home | help 
std::experi...cessIterator(3)  C++ Standard Libary std::experi...cessIterator(3)

NAME
     std::experimental::ranges::RandomAccessIterator	  -	 std::experimen-
     tal::ranges::RandomAccessIterator

Synopsis
	Defined in header <experimental/ranges/iterator>
	template< class I >

	concept bool RandomAccessIterator =
	    BidirectionalIterator<I> &&
	    DerivedFrom<ranges::iterator_category_t<I>,
	ranges::random_access_iterator_tag> &&
	    StrictTotallyOrdered<I> &&
	    SizedSentinel<I, I> &&
	    requires(I i, const I j,  const  ranges::difference_type_t<I>  n)  {
     (ranges TS)
		{ i += n } -> Same<I>&;
		{ j + n }  -> Same<I>&&;
		{ n + j }  -> Same<I>&&;
		{ i -= n } -> Same<I>&;
		{ j - n }  -> Same<I>&&;
		j[n];
		requires Same<decltype(j[n]), ranges::reference_t<I>>;

	    };

	The  concept  RandomAccessIterator<I>  refines	BidirectionalIterator by
     adding support
	for constant time advancement with the +=, +, -=, and - operators,  con-
     stant time
	computation of distance with -, and array notation with subscripting.

	Let  a	and b be valid iterators of type I such that b is reachable from
     a, and let n
	be a value of type ranges::difference_type_t<I> equal to b - a.
	RandomAccessIterator<I> is satisfied only if:

	  * (a += n) is equal to b.
	  * std::addressof(a += n) is equal to std::addressof(a).
	  * (a + n) is equal to (a += n).
	  * (a + n) is equal to (n + a).
	  * For any two positive integers x and y, if a + (x + y) is valid, then
     a + (x + y)
	    is equal to (a + x) + y.
	  * a + 0 is equal to a.
	  * If (a + (n - 1)) is valid, then --b is equal to (a + (n - 1)).
	  * (b += -n) and (b -= n) are both equal to a.
	  * std::addressof(b -= n) is equal to std::addressof(b).
	  * (b - n) is equal to (b -= n).
	  * If b is dereferenceable, then a[n] is valid and is equal to *b.
	  * bool(a <= b) is true .

	Equality preservation

	An expression is equality preserving if  it  results  in  equal  outputs
     given equal
	inputs.

	  * The inputs to an expression consist of its operands.
	  *  The outputs of an expression consist of its result and all operands
     modified by
	    the expression (if any).

	Every expression required to be equality preserving is further	required
     to be
	stable:  two  evaluations  of such an expression with the same input ob-
     jects must have
	equal outputs absent any explicit intervening modification of those  in-
     put objects.

	Unless	noted  otherwise, every expression used in a requires-expression
     is required
	to be equality preserving and stable, and the evaluation of the  expres-
     sion may only
	modify its non-constant operands. Operands that are constant must not be
     modified.

	Implicit expression variations

	A  requires-expression that uses an expression that is non-modifying for
     some
	constant lvalue operand also implicitly requires  additional  variations
     of that
	expression  that  accept  a  non-constant  lvalue or (possibly constant)
     rvalue for the
	given operand unless such an expression variation is explicitly required
     with
	differing semantics. These implicit expression variations must meet  the
     same
	semantic requirements of the declared expression. The extent to which an
	implementation validates the syntax of the variations is unspecified.

http://cppreference.com 	   2024.06.10	   std::experi...cessIterator(3)
home | help