std::ranges::view::iota, std::ranges::iota_view

template<WeaklyIncrementable W, Semiregular Bound = unreachable_sentinel_t> requires _WeaklyEqualityComparableWith<W, Bound> class iota_view : public view_interface<iota_view<W, Bound>>	(1)	(since C++20)
namespace view { 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 both bounded and unbounded (infinite)

2) view::iota(E) and view::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

Data members

std::ranges::iota_view::base_

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

the current value

std::ranges::iota_view::pred_

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

the bound (defaults to std::unreachable_sentinel_t)

Member functions

std::ranges::iota_view::iota_view

iota_view() = default;	(1)
constexpr explicit iota_view(W value);	(2)
constexpr iota_view(std::type_identity_t<W> value, std::type_identity_t<Bound> bound);	(3)

1) Default-initializes value_ and bound_

2) Initializes value_ with value and expects that Bound is either unreachable_sentinel_t (the default) or Bound() is reachable from value. 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. This constructor is used to create bounded iota views, e.g. iota(10, 20) yields numbers from 10 to 19.

Parameters

value	-	the starting value
bound	-	the bound

std::ranges::iota_view::begin

constexpr iterator begin();

Returns the iterator initialized with value_

std::ranges::iota_view::end

constexpr sentinel end() const;	(1)
constexpr iterator end() const requires Same<W, Bound>;	(2)

Returns the iterator initialized with bound_ if this view is bounded, or the sentinel initialized with bound_ if this view is unbounded.

std::ranges::iota_view::size

constexpr auto size() const requires (Same<W, Bound> && _Advanceable<W>) \|\| (Integral<W> && Integral<Bound>) \|\| SizedSentinel<Bound, W> { return bound_ - value_; }

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

Deduction guides

template<class W, class Bound> requires (!Integral<W> \|\| !Integral<Bound> \|\| is_signed_v<W> == is_signed_v<Bound>) iota_view(W, Bound) -> iota_view<W, Bound>;

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

Nested classes

std::ranges::iota_view::iterator

template<class W, class Bound> struct iota_view<W, Bound>::iterator /* exposition-only */

The return type of iota_view::begin.

This is a RandomAccessIterator if W models _Advanceable, a BidirectionalIterator if W models _Decrementable, a ForwardIterator if W models Incrementable, and InputIterator otherwise.

std::ranges::iota_view::iterator::iterator

constexpr explicit iterator(W value);

Initializes exposition-only data member value_ with value. This value will be returned by operator* and incremented by operator++

std::ranges::iota_view::iterator::operator*

constexpr W operator*() const noexcept(is_nothrow_copy_constructible_v<W>);

returns the current value, by value (in other words, this is a read-only view)

std::ranges::iota_view::iterator::operator++

constexpr iterator& operator++()

Equivalent to

++value_;
return *this;

std::ranges::iota_view::iterator::operator--

constexpr iterator& operator--() requires _Decrementable<W>;

Equivalent to

--value_;
return *this;

std::ranges::iota_view::iterator::operator[]

constexpr W operator[](difference_type n) const requires _Advanceable<W>;

Equivalent to

return value_ + n;

Other members as expected of an iterator.

std::ranges::iota_view::sentinel

template<class W, class Bound> struct iota_view<W, Bound>::sentinel /* exposition-only */

The return type of iota_view::end.

std::ranges::iota_view::sentinel::bound_

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

Exposition-only data member holding the sentinel (typically either a number, for a bounded iota view, or an instance of std::unreachable_sentinel_t for an unbounded iota view.

std::ranges::iota_view::sentinel::sentinel

entinel() = default; constexpr explicit sentinel(Bound bound);

Initializes exposition-only data member bound_ with bound.

std::ranges::iota_view::sentinel::operator==

friend constexpr bool operator==(const iterator& x, const sentinel& y); friend constexpr bool operator==(const sentinel& x, const iterator& y);

Equivalent to: x.value_ == y.bound_; and return y == x; respectively.

std::ranges::iota_view::sentinel::operator!=

friend constexpr bool operator!=(const iterator& x, const sentinel& y); friend constexpr bool operator!=(const sentinel& x, const iterator& y);

Equivalent to return !(x == y); and return !(y == x); respectively

Example

Run this code

#include <ranges>
#include <vector>
#include <iostream>
 
int main()
{
  for (int i : std::view::iota{1, 10})
    std::cout << i << ' ';
 
  std::cout << '\n';
 
  for (int i : std::view::iota(1) | std::view::take(9))
    std::cout << i << ' ';
}

Output:

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

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications