std::ranges::views::iota, std::ranges::iota_view - cppreference.com (original) (raw)

Defined in header
template< std::weakly_incrementable W, std::semiregular Bound = std::unreachable_sentinel_t > requires /*weakly-equality-comparable-with*/<W, Bound> && std::copyable<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)
Call signature
template< class W > requires /* see below */ constexpr /* see below */ iota( W&& value ); (since C++20)
template< class W, class Bound > requires /* see below */ constexpr /* see below */ iota( W&& value, Bound&& bound ); (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 iota_view<std::decay_t<decltype((e))>>(e) and iota_view(e, f) respectively for any suitable subexpressions e and f.

Contents

Customization point objects

The name views::iota denotes a customization point object, which is a const function object of a literal semiregular class type. See CustomizationPointObject for details.

[edit] Data members

Member Definition
W value_ the beginning value(exposition-only member object*)
Bound bound_ the sentinel value, may be unreachable(exposition-only member object*)

[edit] Member functions

(constructor) creates an iota_view (public member function)
begin obtains the beginning iterator of an iota_view (public member function)
end obtains the sentinel denoting the end of an iota_view (public member function)
empty tests whether the iota_view is empty (i.e. the iterator and the sentinel compare equal) (public member function)
size(optional) obtains the size of an iota_view (only provided if it is bounded) (public member function)
Inherited from std::ranges::view_interface
cbegin(C++23) returns a constant iterator to the beginning of the range (public member function of std::ranges::view_interface) [edit]
cend(C++23) returns a sentinel for the constant iterator of the range (public member function of std::ranges::view_interface) [edit]
operator bool returns whether the derived view is not empty, provided only if ranges::empty is applicable to it (public member function of std::ranges::view_interface) [edit]
front returns the first element in the derived view, provided if it satisfies forward_range (public member function of std::ranges::view_interface) [edit]
back returns the last element in the derived view, provided only if it satisfies bidirectional_range and common_range (public member function of std::ranges::view_interface) [edit]
operator[] returns the nth element in the derived view, provided only if it satisfies random_access_range (public member function of std::ranges::view_interface) [edit]

[edit] Deduction guides

[edit] Nested classes

| | the iterator type(exposition-only member class*) | | ------------------------------------------------------------------------------------------------------------------------------ | | | the sentinel type used when the iota_view is bounded and Bound and W are not the same type(exposition-only member class*) |

[edit] Helper templates

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

[edit] Example

#include #include #include   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'; }

Output:

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

[edit] Defect reports

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

DR Applied to Behavior as published Correct behavior
LWG 4096 C++20 views::iota could copy an iota_view as-is forbidden
P2325R3 C++20 iota_view required that W is semiregularas view required default_initializable only requires that W is copyable

[edit] See also