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

struct /iterator/;	(1)	(с C++20) (только для примера*)
Вспомогательные шаблоны псевдонимов
template< class I > using /iota-diff-t/ = /* see below */;	(2)	(только для примера*)
Вспомогательные концепции
template< class I > concept /decrementable/ = std::incrementable<I> && requires(I i) { { --i } -> std::same_as<I&>; { i-- } -> std::same_as<I>; };	(3)	(только для примера*)
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>>; };	(4)	(только для примера*)

1) Тип возвращаемого значения для iota_view::begin.

2) Шаблон псевдонима /*iota-diff-t*/ вычисляет тип разности для обоих типов итераторов и целочисленных типов.

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

3) Концепция decrementable определяет, что тип является incrementable, а пред- и пост-operator-- для типа имеют общее значение.

4) Концепция advanceable определяет, что тип является как decrementable , так и totally_ordered, и operator+=, operator-=, operator+, и operator- между типом и его различными типами имеют общее значение.

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

3) Тип I моделирует decrementable только если I удовлетворяет decrementable и все подчинённые концепции моделируются, и заданы равные объекты a и b типа I:

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

4) Пусть D обозначает /*iota-diff-t*/. Тип I моделирует advanceable только если I удовлетворяет advanceable и все подчинённые концепции моделируются, и заданы

объекты 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`	`std::random_access_iterator_tag` если `W` моделирует `advanceable`. В противном случае, `std::bidirectional_iterator_tag` если `W` моделирует `decrementable`. В противном случае, `std::forward_iterator_tag` если `W` моделирует `incrementable`. В противном случае, `std::input_iterator_tag`.
`iterator_category`	`std::input_iterator_tag` если `W` моделирует `incrementable`. В противном случае, тип `iterator_category` отсутствует.
`value_type`	`W`
`difference_type`	`/iota-diff-t/<W>`

Примечания: /*iterator*/

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

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

Члены данных

Имя члена	Определение
`value_` (private)	Значение типа `W`, используемое для обращения к элементу. (только для примера — объект члена*)

Члены-функции

std::ranges::iota_view::iterator::iterator

/iterator/() requires std::default_initializable<W> = default;	(1)	(с C++20)
constexpr explicit /iterator/( W value );	(2)	(с C++20)

1) Инициализирует член данных value_ через его инициализатор по умолчанию (= W()).

2) Инициализирует член данных value_ значением value. Это значение будет возвращено operator* и увеличено на operator++.

std::ranges::iota_view::iterator::operator*

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

(с C++20)

Возвращает текущее значение по значению (другими словами, это просмотр только для чтения).

END_OF_DOCUMENT_MARKER

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

constexpr /iterator/& operator++();	(1)	(с C++20)
constexpr void operator++(int);	(2)	(с C++20)
constexpr /iterator/ operator++(int) requires std::incrementable<W>;	(3)	(с C++20)

1) Эквивалентно ++value_; return *this;.

2) Эквивалентно ++value_;.

3) Эквивалентно auto tmp = *this; ++value_; return tmp;.

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

constexpr /iterator/& operator--() requires /decrementable/<W>;	(1)	(с C++20)
constexpr /iterator/operator--(int) requires /decrementable/<W>;	(2)	(с C++20)

1) Эквивалентно --value_; return *this;.

2) Эквивалентно auto tmp = *this; --value_; return tmp;.

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

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

(с C++20)

Если W — целого типа без знака, выполняет value_ += static_cast<W>(n) если n неотрицательно, value -= static_cast<W>(-n) в противном случае, а затем возвращает *this.

В противном случае, эквивалентно value_ += n; return *this;.

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

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

(с C++20)

Если W — целого типа без знака, выполняет value_ -= static_cast<W>(n) если n неотрицательно, или value += static_cast<W>(-n) в противном случае, а затем возвращает *this.

В противном случае, эквивалентно value_ -= n; return *this;.

std::ranges::iota_view::iterator::operator[]

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

(с C++20)

Эквивалентно return W(value_ + n);.

Нечленные функции

operator==, <, >, <=, >=, <=>(std::ranges::iota_view::iterator)

friend constexpr bool operator== ( const /iterator/& x, const /iterator/& y ) requires std::equality_comparable<W>;	(1)	(с C++20)
friend constexpr bool operator< ( const /iterator/& x, const /iterator/& y ) requires std::totally_ordered<W>;	(2)	(с C++20)
friend constexpr bool operator> ( const /iterator/& x, const /iterator/& y ) requires std::totally_ordered<W>;	(3)	(с C++20)
friend constexpr bool operator<= ( const /iterator/& x, const /iterator/& y ) requires std::totally_ordered<W>;	(4)	(с C++20)
friend constexpr bool operator>= ( const /iterator/& x, const /iterator/& y ) requires std::totally_ordered<W>;	(5)	(с C++20)
friend constexpr bool operator<=>( const /iterator/& x, const /iterator/& y ) requires std::totally_ordered<W> && std::three_way_comparable<W>;	(6)	(с C++20)

1) Эквивалентно return x.value_ == y.value_;.

2) Эквивалентно return x.value_ < y.value_;.

3) Эквивалентно return y < x;.

4) Эквивалентно return !(y < x);.

5) Эквивалентно return !(x < y);.

6) Эквивалентно return x.value_ <=> y.value_;.

Оператор != синтезируется из operator==.

Эти функции не видны для обычного неквалифицированного или квалифицированного поиска и могут быть найдены только с помощью поиска, зависящего от аргументов, когда iterator является ассоциированным классом аргументов.

operator+(std::ranges::iota_view::iterator)

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

(1)

(с C++20)

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

(2)

(с C++20)

Эквивалентно i += n; return i;.

operator-(std::ranges::iota_view::iterator)

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

(1)

(с C++20)

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

(2)

(с C++20)

1) Эквивалентно i -= n; return i;.

2) Пусть D — difference_type.

Если W со знаком, эквивалентно return D(D(x.value_) - D(y.value_));.
В противном случае, если W без знака, эквивалентно return y.value_ > x.value_ ? D(-D(y.value_ - x.value_)) : D(x.value_ - y.value_);.
В противном случае, эквивалентно return x.value_ - y.value_;.

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

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

DR	Применено к	Поведение, опубликованное	Корректное поведение
P2259R1	C++20	член `iterator_category` всегда определен	определен только если `W` удовлетворяет `incrementable`
LWG 3580	C++20	тела `operator+` и `operator-` исключают явное перемещение	пригодны для явного перемещения

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/ranges/iota_view/iterator