std::ranges:: views:: iota, std::ranges:: iota_view
Defined in header
<ranges>
|
||
template
<
std::
weakly_incrementable
W,
std::
semiregular
Bound
=
std::
unreachable_sentinel_t
>
|
(1) | (since C++20) |
namespace
views
{
inline
constexpr
/* unspecified */
iota
=
/* unspecified */
;
|
(2) | (since C++20) |
Call signature
|
||
template
<
class
W
>
requires
/* see below */
|
(since C++20) | |
template
<
class
W,
class
Bound
>
requires
/* see below */
|
(since C++20) | |
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
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 std::ranges::view_interface |
|
(C++23)
|
returns a constant iterator to the beginning of the range.
(public member function of
std::ranges::view_interface<D>
)
|
(C++23)
|
returns a sentinel for the constant iterator of the range.
(public member function of
std::ranges::view_interface<D>
)
|
returns whether the derived view is not empty. Provided if
ranges::empty
is applicable to it.
(public member function of
std::ranges::view_interface<D>
)
|
|
returns the first element in the derived view. Provided if it satisfies
forward_range
.
(public member function of
std::ranges::view_interface<D>
)
|
|
returns the last element in the derived view. Provided if it satisfies
bidirectional_range
and
common_range
.
(public member function of
std::ranges::view_interface<D>
)
|
|
returns the
n
th
element in the derived view. Provided if it satisfies
random_access_range
.
(public member function of
std::ranges::view_interface<D>
)
|
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
(C++11)
|
fills a range with successive increments of the starting value
(function template) |
(C++23)
|
fills a range with successive increments of the starting value
(algorithm function object) |
a
view
consisting of a generated sequence by repeatedly producing the same value
(class template) (customization point object) |