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

< cpp‎ | ranges
Defined in header <ranges>
template<std::weakly_incrementable W,

         std::semiregular Bound = std::unreachable_sentinel_t>
    requires __WeaklyEqualityComparableWith<W, Bound> && std::semiregular<W>

class iota_view : public ranges::view_interface<iota_view<W, Bound>>
(1) (since C++20)
namespace views {

    inline constexpr /*unspecified*/ iota = /*unspecified*/;

(2) (since C++20)
1) A range factory that generates a sequence of elements by repeatedly incrementing an initial value. Can be either bounded or unbounded (infinite)
2) views::iota(E) and views::iota(E, F) are expression-equivalent to (has the same effect as) iota_view{E} and iota_view{E, F} respectively for any suitable subexpressions E and F


[edit] Expression-equivalent

Expression e is expression-equivalent to expression f, if e and f have the same effects, either are both potentially-throwing or are both not potentially-throwing (i.e. noexcept(e) == noexcept(f)), and either are both constant subexpressions or are both not constant subexpressions.

[edit] 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.

[edit] Data members


W value_ = W(); /* exposition-only */

the current value


Bound bound_ = Bound(); /* exposition-only */

the bound (defaults to std::unreachable_sentinel_t)

[edit] Member functions


iota_view() = default;
constexpr explicit iota_view(W value);
constexpr iota_view(std::type_identity_t<W> value,
                    std::type_identity_t<Bound> bound);
1) Value-initializes value_ and bound_.
2) Initializes value_ with value and value-initializes bound_. This constructor is used to create unbounded iota_views, e.g. iota(0) yields numbers 0,1,2..., infinitely.
3) Initializes value_ with value and bound_ with bound. The behavior is undefined if std::totally_ordered_with<W, Bound> is modeled and bool(value <= bound) is false. This constructor is used to create bounded iota views, e.g. iota(10, 20) yields numbers from 10 to 19.

For (2) and (3), the behavior is undefined if the iota_view is bounded (i.e. Bound is not std::unreachable_sentinel_t) and bound_ is initialized to a value unreachable from value.


value - the starting value
bound - the bound


constexpr /*iterator*/ begin() const;

Returns an iterator initialized with value_.


constexpr auto end() const;
constexpr /*iterator*/ end() const requires std::same_as<W, Bound>;
1) Returns a sentinel of a specific type initialized with bound_ if this view is bounded, or std::unreachable_sentinel if this view is unbounded.
2) Returns an iterator initialized with bound_.


constexpr auto size() const

  requires (std::same_as<W, Bound> && __Advanceable<W>) ||
           (std::integral<W> && std::integral<Bound>) ||
             std::sized_sentinel_for<Bound, W>
  if constexpr (__IsIntegerLike<W> && __IsIntegerLike<Bound>)
    return (value_ < 0)
      ? ((bound_ < 0)
        ? __MakeUnsignedLike(-value_) - __MakeUnsignedLike(-bound_)
        : __MakeUnsignedLike(bound_) + __MakeUnsignedLike(-value_))
      : __MakeUnsignedLike(bound_) - __MakeUnsignedLike(value_);
    return __MakeUnsignedLike(bound_ - value_);


Returns the size of the view if the view is bounded.

[edit] Deduction guides

template<class W, class Bound>

    requires (!__IsIntegerLike<W> || !__IsIntegerLike<Bound> ||
              __IsSignedIntegerLike<W> == __IsSignedIntegerLike<Bound>)

  iota_view(W, Bound) -> iota_view<W, Bound>;

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.

[edit] Nested classes

the iterator type
(public member class)
the sentinel type used when the iota_view is bounded and Bound and W are not the same type
(public member class)

[edit] Example

#include <ranges>
#include <iostream>
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) | std::views::take(9))
        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

[edit] See also

fills a range with successive increments of the starting value
(function template) [edit]