# std::weakly_incrementable

> C++ Atlas: `cppatlas.com/w/cpp/iterator/weakly_incrementable` | Source: https://en.cppreference.com/w/cpp/iterator/weakly_incrementable | Domain: Iterator | Standards: C++20

For the definition of /*is-signed-integer-like*/, see is-integer-like .

## Official Specification Summary (cppreference)

```cpp
// 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)
```

For the definition of `/*is-signed-integer-like*/`, see `is-integer-like`.

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

### Semantic requirements

For an object `i` of type `I`, `I` models `std::weakly_incrementable` only if all following conditions are satisfied:

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

### Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

| DR | Applied to | Behavior as published | Correct behavior |
| --- | --- | --- | --- |
| P2325R3 | C++20 | `default_initializable` was required | not required |

### See also

- [`incrementable`](https://en.cppreference.com/w/cpp/iterator/incrementable) (C++20): specifies that the increment operation on a `weakly_incrementable` type is equality-preserving and that the type is `equality_comparable` (concept)

---
Attribution: content from https://en.cppreference.com/w/cpp/iterator/weakly_incrementable (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.