#MAGICTITLESTRING#

<tbody> </tbody>

Определено в заголовочном файле <ranges>
template< std::weakly_incrementable W, std::semiregular Bound = std::unreachable_sentinel_t > requires __WeaklyEqualityComparableWith<W, Bound> && std::copyable<W> class iota_view : public ranges::view_interface<iota_view<W, Bound>>	(1)	(начиная с C++20)
namespace views { inline constexpr /* unspecified */ iota = /* unspecified */; }	(2)	(начиная с C++20)
Сигнатура вызова
template< class W > requires /* see below */ constexpr /* see below */ iota( W&& value );		(начиная с C++20)
template< class W, class Bound > requires /* see below */ constexpr /* see below */ iota( W&& value, Bound&& bound );		(начиная с C++20)

1) Фабрика диапазонов, которая генерирует последовательность элементов путем многократного увеличения начального значения. Может быть ограниченным или неограниченным (бесконечным).

2) views::iota(e) и views::iota(e, f) эквивалентны выражению iota_view(e) и iota_view(e, f) соответственно для любых подходящих подвыражений e и f.

Объекты точек настройки

Имя views::iota обозначает объект точки настройки, который является константным функциональным объектом литерального классового типа semiregular. В целях наглядности версия этого типа без cv-квалификации обозначается как __iota_fn.

Все экземпляры __iota_fn равны. Эффекты от вызова разных экземпляров типа __iota_fn для одних и тех же аргументов эквивалентны, независимо от того, является ли выражение, обозначающее экземпляр, lvalue или rvalue, и является ли оно константным или нет (однако volatile-квалифицированный экземпляр не требуется для вызова). Таким образом, views::iota можно свободно копировать, а его копии можно использовать взаимозаменяемо.

Учитывая набор типов Args..., если std::declval<Args>()... соответствует требованиям к аргументам для views::iota выше, __iota_fn модели

• std::invocable<__iota_fn, Args...>,
• std::invocable<const __iota_fn, Args...>,
• std::invocable<__iota_fn&, Args...> и
• std::invocable<const __iota_fn&, Args...>.
  

Иначе, оператор вызова функции __iota_fn не участвует в разрешении перегрузки.

Свойства

Имя	Описание
value_	Начальное значение этого типа W. (только для пояснения объект элемент of *)
bound_	Охранное выражение значения этого типа Bound. (только для пояснения объект элемент*)

Методы

(конструктор) (C++20)	создает iota_view (public функция-элемент)
begin (C++20)	получает начальный итератор iota_view (public функция-элемент)
end (C++20)	получает сигнал, обозначающий конец iota_view (public функция-элемент)
size (C++20)	получает размер iota_view если он по размеру (public функция-элемент)
Унаследовано от ranges::view_interface
empty (C++20)	возвращает является ли производное представление пустым. При условии, если это удовлетворяет sized_range или forward_range. (public функция-элемент std::ranges::view_interface<D>)
cbegin (C++23)	возвращает константный итератор в начале диапазона. (public функция-элемент std::ranges::view_interface<D>)
cend (C++23)	возвращает охранное выражение для константного итератора диапазона. (public функция-элемент std::ranges::view_interface<D>)
operator bool (C++20)	возвращает, не является ли производное представление пустым. Существует, если ranges::empty применимо к нему. (public функция-элемент std::ranges::view_interface<D>)
front (C++20)	возвращает первый элемент в производном представлении. При условии, если оно удовлетворяет forward_range. (public функция-элемент std::ranges::view_interface<D>)
back (C++20)	возвращает последний элемент в производном представлении. При условии, если оно удовлетворяет bidirectional_range и common_range. (public функция-элемент std::ranges::view_interface<D>)
operator[] (C++20)	возвращает нный элемент в производном представлении. При условии, если оно удовлетворяет random_access_range. (public функция-элемент std::ranges::view_interface<D>)

std::ranges::iota_view::iota_view

<tbody> </tbody>

iota_view() requires std::default_initializable<W> = default;	(1)	(начиная с C++20)
constexpr explicit iota_view( W value );	(2)	(начиная с C++20)
constexpr explicit iota_view( std::type_identity_t<W> value, std::type_identity_t<Bound> bound );	(3)	(начиная с C++20)
constexpr explicit iota_view( /* iterator */ first, /* see below */ last );	(4)	(начиная с C++20)

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

2) Инициализирует value_ с value и инициализирует значение bound_. Этот конструктор используется для создания неограниченного iota_views, например iota(0) дает числа 0,1,2..., бесконечно.

3) Инициализирует value_ с value и bound_ с bound. Поведение неопределенно, если std::totally_ordered_with<W, Bound> моделируется и bool(value <= bound) false. Этот конструктор используется для создания ограниченных представлений йоты, например iota(10, 20) дает числа от 10 до 19.

4) То же, что и (3), за исключением того, что value_ инициализируется значением W, из first, и

• если W и Bound принадлежат одному типу, тогда типом last является /* iterator */ и bound_ инициализируется с помощью W значения, содержащегося в last,
• иначе, если iota_view неограничено (т.е. Bound является std::unreachable_sentinel_t), тогда тип last это std::unreachable_sentinel_t и bound_ инициализируется std::unreachable_sentinel.
• иначе, типы last, /* sentinel */ и bound_ инициализированы с Bound значением, хранимым в last.

В любом случае, тип last аналогичен decltype(end()).

Для (2), (3), и (4), поведение неопределено если iota_view ограничено (т.е. Bound не std::unreachable_sentinel_t) и bound_ инициализировано значением, недоступным из value_.

Параметры

value	—	начальное значение
bound	—	граница
first	—	итератор на начальное значение
last	—	итератор или охранное выражение на границу

std::ranges::iota_view::begin

<tbody> </tbody>

constexpr /* iterator */ begin() const;		(начиная с C++20)

Возвращает iterator инициализированный с value_.

std::ranges::iota_view::end

<tbody> </tbody>

constexpr auto end() const;	(1)	(начиная с C++20)
constexpr /* iterator */ end() const requires std::same_as<W, Bound>;	(2)	(начиная с C++20)

1) Возвращает sentinel определенного типа (показанного как /* sentinel */ тут) инициализированного с bound_ если это представление ограничено или std::unreachable_sentinel если представление не ограничено.

2) Возвращает iterator инициализированный с bound_.

std::ranges::iota_view::size

<tbody> </tbody>

constexpr auto size() const requires (std::same_as<W, Bound> && /* advanceable */<W>) || (/* is-integer-like */<W> && /* is-integer-like */<Bound>) || std::sized_sentinel_for<Bound, W> { if constexpr (/* is-integer-like */<W> && /* is-integer-like */<Bound>) return (value_ < 0) ? ((bound_ < 0) ? /* to-unsigned-like */(-value_) - /* to-unsigned-like */(-bound_) : /* to-unsigned-like */(bound_) + /* to-unsigned-like */(-value_)) : /* to-unsigned-like */(bound_) - /* to-unsigned-like */(value_); else return /* to-unsigned-like */(bound_ - value_); }		(начиная с C++20)

Возвращает размер ограниченного представления.

Концепт предназначенный только для представления advanceable описан тут.

Шаблон функции только для представления to-unsigned-like преобразует свой аргумент (который должен быть integer-like) в соответствующую беззнаковую версию типа аргумента.

Deduction guides

<tbody> </tbody>

template< class W, class Bound > requires (!/* is-integer-like */<W> || !/* is-integer-like */<Bound> || /* is-signed-integer-like */<W> == /* is-signed-integer-like */<Bound>) iota_view( W, Bound ) -> iota_view<W, Bound>;		(начиная с C++20)

Для любого типа T, /* is-integer-like */<T> = true истинно тогда и только тогда, когда T является integer-like, и /* is-signed-integer-like */<T> = true истинно тогда и только тогда, когда T является целочисленным и может представлять отрицательные значения.

Обратите внимание, что руководство защищает себя от ошибок несоответствия знаков и беззнаков, таких как views::iota(0, v.size()), где 0 это (signed) int и v.size() это (unsigned) std::size_t.

Вложенные классы

iterator (C++20)	тип итератора (класс-элемент только для пояснения)
sentinel (C++20)	тип охранного выражения, используемый когда iota_view ограничен и Bound и W имеют разные типы (класс-элемент только для пояснения)

Вспомогательные шаблоны

<tbody> </tbody>

template< std::weakly_incrementable W, std::semiregular Bound > inline constexpr bool enable_borrowed_range<ranges::iota_view<W, Bound>> = true;		(начиная с C++20)

Эта специализация std::ranges::enable_borrowed_range позволяет iota_view соответствовать borrowed_range.

Примеры

Запустить этот код

#include <algorithm>
#include <iostream>
#include <ranges>
    
struct Bound
{
    int bound;
    bool operator==(int x) const { return x == bound; }
};

int main()
{
    for (int i : std::ranges::iota_view{1, 10})
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int i : std::views::iota(1, 10))
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int i : std::views::iota(1, Bound{10}))
        std::cout << i << ' ';
    std::cout << '\n';
    
    for (int i : std::views::iota(1) | std::views::take(9))
        std::cout << i << ' ';
    std::cout << '\n';
    
    std::ranges::for_each(std::views::iota(1, 10), [](int i)
    {
        std::cout << i << ' ';
    });
    std::cout << '\n';
}

Вывод:

1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9

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

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Номер	Применён	Поведение в стандарте	Корректное поведение
LWG 3523	C++20	конструктор пары итератор-охранное выражение мог неправильно выбрать тип охранного выражения	исправлено
LWG 3610	C++20	size мог отклонить типы целочисленного класса	принимает если возможно
LWG 3714	C++20	многопараметрические конструкторы не были явными	сделаны явными
WG не указан	C++20	iota_view требовала, чтобы W был semiregular как требует view default_initializable	требуется только чтобы W был copyable

Смотри также

iota (C++11)	заполняет диапазон последовательными приращениями начального значения (шаблон функции)
ranges::iota (C++23)	заполняет диапазон последовательными приращениями начального значения (ниблоид)
ranges::repeat_viewviews::repeat (C++23)	view, состоящее из последовательности сгенерированной путём повторного создания одного и того же значения (шаблон класса) (объект точки настройки)