Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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

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

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

	  concept bool WeaklyIncrementable =
	  Semiregular<I> &&
	  requires(I i)	{
	  typename				 ranges::difference_type_t<I>;
       (ranges TS)
	  requires SignedIntegral<ranges::difference_type_t<I>>;
	  { ++i	} -> Same<I>&; /* not required to be equality preserving */
	  i++; /* not required to be equality preserving */

	  };

	  The  concept	WeaklyIncrementable<I> specifies the requirements on a
       type that can be
	  incremented (with the	pre- and post-increment	operators). The	incre-
       ment operations
	  need not be equality-preserving, and the type	need not be  Equality-
       Comparable.

	  Let i	be an object of	type I.	i is said to be	incrementable if it is
       in the domain
	  of both pre- and post-increment. WeaklyIncrementable<I> is satisfied
       only if:

	    * ++i and i++ have the same	domain;
	    * If i is incrementable, then:

		 * ++i and i++ both advance i to the next element; and
		 * ++i refers to the same object as i.

	 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 re-
       quired to be
	  stable: two evaluations of such an expression	with  the  same	 input
       objects must have
	  equal	 outputs absent	any explicit intervening modification of those
       input objects.

Notes
	  For WeaklyIncrementable types, a equals b does not  imply  that  ++a
       equals ++b.
	  Algorithms  on such types should be single pass and never attempt to
       pass through the
	  same value twice.

http://cppreference.com		  2022.07.31	  std::experi...crementable(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::experimental::ranges::WeaklyIncrementable&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help