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

Customization point objects

The name views::iota denotes a customization point object, which is a const function object of a literal semiregular class type. For exposition purposes, the cv-unqualified version of its type is denoted as __iota_fn.

All instances of __iota_fn are equal. The effects of invoking different instances of type __iota_fn on the same arguments are equivalent, regardless of whether the expression denoting the instance is an lvalue or rvalue, and is const-qualified or not (however, a volatile-qualified instance is not required to be invocable). Thus, views::iota can be copied freely and its copies can be used interchangeably.

Given a set of types Args..., if std::declval<Args>()... meet the requirements for arguments to views::iota above, __iota_fn models
.

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

Otherwise, no function call operator of __iota_fn participates in overload resolution.

Data members

Typical implementation of iota_view holds two non-static data members: the beginning value value_ of type W and the sentinel value bound_ of type Bound. The names shown here are exposition-only.

Member functions

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

/* sentinel */

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

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

For any type T, /* is-integer-like */<T> is true if and only if T is integer-like, and /* is-signed-integer-like */<T> is true if and only if T is integer-like and capable of representing negative values.

Note that the guide protects itself against signed/unsigned mismatch bugs, like views::iota(0, v.size()), where ​0​ is a (signed) int and v.size() is an (unsigned) std::size_t.

Nested classes

Helper templates

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

This specialization of std::ranges::enable_borrowed_range makes iota_view satisfy borrowed_range.

Example

#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

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also