std::ranges::views::iota, std::ranges::iota_view, std::ranges::views::indices
Depuis fr.cppreference.net
| Défini dans l'en-tête <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) | (depuis C++20) |
namespace views {
inline constexpr /* unspecified */ iota = /* unspecified */;
}
|
(2) | (depuis C++20) |
namespace views {
inline constexpr /* unspecified */ indices = /* unspecified */;
}
|
(3) | (depuis C++26) |
| Signature d'appel |
||
template< class W >
requires /* see below */
constexpr /* see below */ iota( W&& value );
|
(depuis C++20) | |
template< class W, class Bound >
requires /* see below */
constexpr /* see below */ iota( W&& value, Bound&& bound );
|
(depuis C++20) | |
template< class T >
requires /*is-integer-like*/<T>
constexpr /* see below */ indices( T bound );
|
(depuis C++26) | |
1) Une fabrique de plage qui génère une séquence d'éléments en incrémentant répétitivement une valeur initiale. Peut être soit bornée, soit non bornée (infinie).
2)
views::iota(e) et views::iota(e, f) sont équivalentes par expression à iota_view<std::decay_t<decltype((e))>>(e) et iota_view(e, f) respectivement pour toutes sous-expressions appropriées e et f.3) Soit
T std::remove_cvref_t<decltype((e))>. Alors views::indices(e) est équivalente par expression à views::iota(T(0), e) pour toute sous-expression appropriée e si /*is-integer-like*/<T> est true.Objets de point de personnalisation
Le nom
views::iota
désigne un
objet de point de personnalisation
, qui est un
objet fonction
constant d'un type de classe
littéral
semiregular
. Voir
CustomizationPointObject
pour plus de détails.
Membres de données
| Membre | Description |
W value_
|
la valeur initiale (objet membre d'exposition uniquement*) |
Bound bound_
|
la valeur sentinelle, peut être inaccessible (objet membre d'exposition uniquement*) |
Fonctions membres
crée un
iota_view
(fonction membre publique) |
|
obtient l'itérateur de début d'un
iota_view
(fonction membre publique) |
|
obtient le sentinelle dénotant la fin d'un
iota_view
(fonction membre publique) |
|
teste si le
iota_view
est vide (c'est-à-dire si l'itérateur et le sentinelle sont égaux)
(fonction membre publique) |
|
|
(optional)
|
obtient la taille d'un
iota_view
(fournie uniquement s'il est borné)
(fonction membre publique) |
Hérité de ranges::view_interface | |
(C++23) |
renvoie un itérateur constant au début de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
(C++23) |
renvoie un sentinelle pour l'itérateur constant de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
| renvoie si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable (fonction membre publique de std::ranges::view_interface<D>)
| |
| renvoie le premier élément dans la vue dérivée, fourni si elle satisfait forward_range (fonction membre publique de std::ranges::view_interface<D>)
| |
| renvoie le dernier élément dans la vue dérivée, fourni uniquement si elle satisfait bidirectional_range et common_range (fonction membre publique de std::ranges::view_interface<D>)
| |
renvoie le ne élément dans la vue dérivée, fourni uniquement si elle satisfait random_access_range (fonction membre publique de std::ranges::view_interface<D>)
| |
Guides de déduction
Classes imbriquées
|
le type d'itérateur
( classe membre d'exposition uniquement* ) |
|
le type sentinelle utilisé lorsque le
iota_view
est borné et que
Bound
et
W
ne sont pas du même type
( classe membre d'exposition uniquement* ) |
Modèles d'assistance
|
template
<
std::
weakly_incrementable
W,
std::
semiregular
Bound
>
constexpr bool ranges:: enable_borrowed_range < ranges :: iota_view < W, Bound >> = true ; |
(depuis C++20) | |
Cette spécialisation de
ranges::
enable_borrowed_range
permet à
iota_view
de satisfaire
borrowed_range
.
Implémentation possible
Voir aussi l'implémentation dans libstdc++.
| views::indices (3) |
|---|
namespace views {
inline constexpr auto indices = []</*is-integer-like*/ I>(I n)
{
return views::iota(I{}, n);
};
}
|
Notes
| Macro de test de fonctionnalité | Valeur | Norme | Fonctionnalité |
|---|---|---|---|
__cpp_lib_ranges_indices |
202506L |
(C++26) | ranges::views::indices
|
Exemple
Exécuter ce code
#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';
#if __cpp_lib_ranges_indices
constexpr int v[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
// auto broken_indices = views::iota(0, std::ranges::size(v));
// does not compile due to types (int VS size_t) mismatch
auto good_indices = std::views::indices(std::ranges::size(v));
for (auto i : good_indices)
std::cout << v[i] << ' ';
std::cout << '\n';
#endif
}
Sortie :
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
1 2 3 4 5 6 7 8 9
Rapports de défauts
Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Applicable à | Comportement publié | Comportement corrigé |
|---|---|---|---|
| LWG 4096 | C++20 |
views::iota
pouvait copier un
iota_view
tel quel
|
interdit |
| P2325R3 | C++20 |
iota_view
exigeait que
W
soit
semiregular
car une
view
exigeait
default_initializable
|
exige seulement que
W
soit
copyable
|
Références
- Norme C++26 (ISO/CEI 14882:2026) :
- 25.6.4 Vue Iota [range.iota]
- Norme C++23 (ISO/CEI 14882:2024) :
- 26.6.4 Vue Iota [range.iota]
- Norme C++20 (ISO/CEI 14882:2020) :
- 24.6.4 Vue Iota [range.iota]
Voir aussi
(C++11) |
remplit une plage avec des incréments successifs de la valeur de départ (modèle de fonction & objet fonction d'algorithme) |
(C++23) |
|
(C++23) |
remplit une plage avec des incréments successifs de la valeur de départ (objet fonction d'algorithme) |
| une vue consistant en une séquence générée en produisant répétitivement la même valeur (modèle de classe) (objet point de personnalisation) | |
| une vue qui associe chaque élément d'une séquence adaptée à un tuple contenant à la fois la position de l'élément et sa valeur (modèle de classe) (objet adaptateur de plage) |