< cpp‎ | iterator
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
Iterator adaptors
Stream iterators
Iterator customization points
Iterator operations
Range access
Defined in header <iterator>
template<class I>

  concept weakly_incrementable =
    std::default_initializable<I> && std::movable<I> &&
    requires(I i) {
      typename std::iter_difference_t<I>;
      requires /*is-signed-integer-like*/<std::iter_difference_t<I>>;
      { ++i } -> std::same_as<I&>;   // not required to be equality-preserving
      i++;                           // not required to be equality-preserving

(since C++20)

where /*is-signed-integer-like*/<I> is true if std::signed_integral<I> is true or if I is a class that behaves like a signed integer type including all operators, implicit conversions, and std::numeric_limits specializations.

This concept specifies requirements on types that can be incremented with the pre- and post-increment operators, but those increment operations are not necessarily equality-preserving, and the type itself is not required to be std::equality_comparable.

For std::weakly_incrementable types, a == b does not imply that ++a == ++b. Algorithms on weakly incrementable types must be single-pass algorithms. These algorithms can be used with istreams as the source of the input data through std::istream_iterator.

[edit] Semantic requirements

I models std::weakly_incrementable only if given only object i of type I:

  • The expressions ++i and i++ have the same domain
  • If i is incrementable, then both ++i and i++ advance i
  • If i is incrementable, then std::addressof(++i) == std::addressof(i)

[edit] See also

specifies that the increment operation on a weakly_incrementable type is equality-preserving and that the type is equality_comparable
(concept) [edit]