Home Original page

std::ranges::views::iota, std::ranges::iota_view - cppreference.com

From cppreference.com

Defined in header <ranges>

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.

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.

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

Member functions

creates an iota_view
(public member function)
obtains the beginning iterator of an iota_view
(public member function)
obtains the sentinel denoting the end of an iota_view
(public member function)
tests whether the iota_view is empty (i.e. the iterator and the sentinel compare equal)
(public member function)

(optional)

 obtains the size of an iota_view (only provided if it is bounded)
(public member function)
Inherited from ranges::view_interface

(C++23)

 returns a constant iterator to the beginning of the range
(public member function of std::ranges::view_interface<D>) [edit]

(C++23)

 returns a sentinel for the constant iterator of the range
(public member function of std::ranges::view_interface<D>) [edit]
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<D>) [edit]
returns the first element in the derived view, provided if it satisfies forward_range
(public member function of std::ranges::view_interface<D>) [edit]
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<D>) [edit]
returns the nth element in the derived view, provided only if it satisfies random_access_range
(public member function of std::ranges::view_interface<D>) [edit]

Deduction guides

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

Helper templates

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

 (since C++20)

This specialization of 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';
}

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

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 semiregular
as view required default_initializable 		only requires that W is copyable

See also