std::ranges::iota_view<W, Bound>::iterator

struct /*iterator*/;

template< class I >
using /*iota-diff-t*/ = /* see below */;

template< class I >
concept /*decrementable*/ =
    std::incrementable<I> && requires(I i)
    {
        { --i } -> std::same_as<I&>;
        { i-- } -> std::same_as<I>;
    };

template< class I >
concept /*advanceable*/ =
    /*decrementable*/<I> && std::totally_ordered<I> &&
    requires(I i, const I j, const /*iota-diff-t*/<I> n)
    {
        { i += n } -> std::same_as<I&>;
        { i -= n } -> std::same_as<I&>;
        I(j + n);
        I(n + j);
        I(j - n);
        { j - j } -> std::convertible_to</*iota-diff-t*/<I>>;
    };

• Если I не является целочисленным типом или если он является целочисленным типом и sizeof(std::iter_difference_t<I>) больше, чем sizeof(I), то /*iota-diff-t*/<I> — это std::iter_difference_t<I>.
• В противном случае /*iota-diff-t*/<I> — это знаковый целочисленный тип, ширина которого больше ширины I, если такой тип существует.
• В противном случае I является одним из целочисленных типов наибольшей ширины, а /*iota-diff-t*/<I> — это неуказанный знаковый целочисленноподобный тип, ширина которого не меньше ширины I. Не указано, моделирует ли /*iota-diff-t*/<I> концепт weakly_incrementable в этом случае.

/*iterator*/ моделирует концепт

• random_access_iterator, если W моделирует advanceable (4),
• bidirectional_iterator, если W моделирует decrementable (3),
• forward_iterator, если W моделирует incrementable, и
• input_iterator в противном случае.

Однако он удовлетворяет требованиям LegacyInputIterator, только если W моделирует incrementable; в противном случае он не удовлетворяет требованиям LegacyInputIterator.

Семантические требования

• Если a и b входят в область определения как префиксной, так и постфиксной операции operator-- (то есть для них определена операция декремента), то все следующие выражения true:
  • std::addressof(--a) == std::addressof(a),
  • bool(a-- == b),
  • bool(((void)a--, a) == --b),
  • bool(++(--a) == b).
• Если a и b входят в область определения как префиксной, так и постфиксной операции operator++ (то есть для них определена операция инкремента), то bool(--(++a) == b) является true.

• объектов a и b типа I и
• значения n типа D,

таких, что b достижимо из a после n применений ++a, выполняются все следующие условия:

• (a += n) равно b.
• std::addressof(a += n) равно std::addressof(a).
• I(a + n) равно (a += n).
• Для любых двух положительных значений x и y типа D, если I(a + D(x + y)) корректно определено, то I(a + D(x + y)) равно I(I(a + x) + y).
• I(a + D(0)) равно a.
• Если I(a + D(n - 1)) корректно определено, то I(a + n) равно [](I c) { return ++c; }(I(a + D(n - 1))).
• (b += -n) равно a.
• (b -= n) равно a.
• std::addressof(b -= n) равно std::addressof(b).
• I(b - n) равно (b -= n).
• D(b - a) равно n.
• D(a - b) равно D(-n).
• bool(a <= b) является true.

Вложенные типы

Определение концепта итератора

iterator_concept определяется следующим образом:

• Если W моделирует advanceable, iterator_concept обозначает std::random_access_iterator_tag.
• В противном случае, если W моделирует decrementable, iterator_concept обозначает std::bidirectional_iterator_tag.
• В противном случае, если W моделирует incrementable, iterator_concept обозначает std::forward_iterator_tag.
• В противном случае iterator_concept обозначает std::input_iterator_tag.

Поля данных

Функции-члены

/*iterator*/() requires std::default_initializable<W> = default;

constexpr explicit /*iterator*/( W value );

constexpr W operator*() const
    noexcept(std::is_nothrow_copy_constructible_v<W>);

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // binds with temporary
    assert(*it == 6 and r == 6);
    ++it;
    assert(*it == 7 and r == 6);
}

constexpr /*iterator*/& operator++();

constexpr void operator++(int);

constexpr /*iterator*/ operator++(int) requires std::incrementable<W>;

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*++it == 9);
    assert(*it++ == 9);
    assert(*it == 10);
}

constexpr /*iterator*/& operator--() requires /*decrementable*/<W>;

constexpr /*iterator*/operator--(int) requires /*decrementable*/<W>;

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*--it == 7);
    assert(*it-- == 7);
    assert(*it == 6);
}

std::ranges::iota_view::iterator::operator+=

constexpr /*iterator*/& operator+=( difference_type n )
    requires /*advanceable*/<W>;

Обновляет value_ и возвращает *this:

• Если W является беззнаковым целочисленноподобным типом:
  • Если n неотрицательно, выполняет value_ += static_cast<W>(n).
  • В противном случае выполняет value_ -= static_cast<W>(-n).
• В противном случае выполняет value_ += n.

Пример

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(5).begin()};
    assert(*it == 5);
    assert(*(it += 3) == 8);
}

std::ranges::iota_view::iterator::operator-=

constexpr /*iterator*/& operator-=( difference_type n )
    requires /*advanceable*/<W>;

Обновляет value_ и возвращает *this:

• Если W является беззнаковым целочисленноподобным типом:
  • Если n неотрицательно, выполняет value_ -= static_cast<W>(n).
  • В противном случае выполняет value_ += static_cast<W>(-n).
• В противном случае выполняет value_ -= n.

Пример

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it -= -3) == 9);
}

constexpr W operator[]( difference_type n ) const
    requires /*advanceable*/<W>;

#include <cassert>
#include <ranges>

int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it + 3) == 9);
}

Функции, не являющиеся членами

friend constexpr bool operator==
    ( const /*iterator*/& x, const /*iterator*/& y )
    requires std::equality_comparable<W>;

friend constexpr bool operator<
    ( const /*iterator*/& x, const /*iterator*/& y )
    requires std::totally_ordered<W>;

friend constexpr bool operator>
    ( const /*iterator*/& x, const /*iterator*/& y )
    requires std::totally_ordered<W>;

friend constexpr bool operator<=
    ( const /*iterator*/& x, const /*iterator*/& y )
    requires std::totally_ordered<W>;

friend constexpr bool operator>=
    ( const /*iterator*/& x, const /*iterator*/& y )
    requires std::totally_ordered<W>;

friend constexpr bool operator<=>
    ( const /*iterator*/& x, const /*iterator*/& y )
    requires std::totally_ordered<W> && std::three_way_comparable<W>;

friend constexpr /*iterator*/ operator+
    ( /*iterator*/ i, difference_type n )
    requires /*advanceable*/<W>;

friend constexpr /*iterator*/ operator+
    ( difference_type n, /*iterator*/ i )
    requires /*advanceable*/<W>;

friend constexpr /*iterator*/ operator-
    ( /*iterator*/ i, difference_type n )
    requires /*advanceable*/<W>;

friend constexpr difference_type operator-
    ( const /*iterator*/& x, const /*iterator*/& y )
    requires /*advanceable*/<W>;

Отчеты об ошибках

Следующие отчеты об ошибках, изменяющие поведение, были применены задним числом к ранее опубликованным стандартам C++.