Пространства имён
Варианты
Действия

#MAGICTITLESTRING#

Материал из cppreference.com
< cpp‎ | ranges

Шаблон:cpp/ranges/iota view/navbar

Определено в заголовочном файле <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 модели

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

[править] Свойства

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

[править] Методы

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

std::ranges::iota_view::iota_view

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

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

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

std::ranges::iota_view::end

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

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

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.

[править] Вложенные классы

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

[править] Вспомогательные шаблоны

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

[править] Смотри также

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