std::ranges::views::iota, std::ranges::iota_view

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

namespace views {
    inline constexpr /* unspecified */ iota = /* unspecified */;
}

template< class W >
    requires /* see below */
constexpr /* see below */ iota( W&& value );

template< class W, class Bound >
    requires /* see below */
constexpr /* see below */ iota( W&& value, Bound&& bound );

Объекты точек кастомизации

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

Все экземпляры __iota_fn равны. Эффекты вызова различных экземпляров типа __iota_fn с одними и теми же аргументами эквивалентны, независимо от того, является ли выражение, обозначающее экземпляр, lvalue или rvalue, и является ли он const-квалифицированным или нет (однако экземпляр с 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 не участвует в разрешении перегрузки.

Члены данных

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

iota_view() requires std::default_initializable<W> = default;

constexpr explicit iota_view( W value );

constexpr explicit iota_view( std::type_identity_t<W> value,
                              std::type_identity_t<Bound> bound );

constexpr explicit iota_view( /* iterator */ first, /* see below */ last );

constexpr /* iterator */ begin() const;

constexpr auto end() const;

constexpr /* iterator */ end() const requires std::same_as<W, Bound>;

constexpr bool empty() const;

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_);
}

Правила вывода типов

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>;

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

Обратите внимание, что данное правило защиты от ошибок несоответствия знакового и беззнакового типов, таких как views::iota(0, v.size()), где ​0​ — (знаковый) int, а v.size() — (беззнаковый) std::size_t.

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

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

template< std::weakly_incrementable W, std::semiregular Bound >
inline constexpr bool enable_borrowed_range<ranges::iota_view<W, Bound>> = true;

Это специализация 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++.

См. также