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

    concept weakly_incrementable =
        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 and only if I is a signed-integer-like type (see below).

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, for an 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, and
  • If i is incrementable, then std::addressof(++i) == std::addressof(i).

[edit] Integer-like types

An integer-like type is an (possibly cv-qualified) integer type (except for cv bool) or an implementation-provided (not user-provided) type that behaves like an integer type, including all operators, implicit conversions, and std::numeric_limits specializations. If an integer-like type represents only non-negative values, it is unsigned-integer-like, otherwise it is signed-integer-like.

[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 3467 C++20 bool was considered as an integer-like type excluded
P2325R3 C++20 default_initializable was required not required

[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]