std::ranges::views::enumerate, std::ranges::enumerate_view
Depuis fr.cppreference.net
| Défini dans l'en-tête <ranges>
|
||
template< ranges::view V >
requires /*range-with-movable-references*/<V>
class enumerate_view
: public ranges::view_interface<enumerate_view<V>>
|
(1) | (depuis C++23) |
namespace views {
inline constexpr /* unspecified */ enumerate = /* unspecified */;
}
|
(2) | (depuis C++23) |
| Signature d'appel |
||
template< ranges::viewable_range R >
requires /* see below */
constexpr /* see below */ enumerate( R&& r );
|
(depuis C++23) | |
| Concepts d'aide |
||
template< class R >
concept /*range-with-movable-references*/ =
ranges::input_range<R> &&
std::move_constructible<ranges::range_reference_t<R>> &&
std::move_constructible<ranges::range_rvalue_reference_t<R>>;
|
(3) | (exposé uniquement*) |
1)
enumerate_view est un adaptateur de plage qui prend une vue et produit une vue de std::tuples. ième élément (le tuple) de la séquence résultante contient :
- la valeur égale à
i, qui est un index de base zéro de l'élément de la séquence sous-jacente, et - la référence à l'élément sous-jacent.
2) Le nom
views::enumerate désigne un RangeAdaptorObject. Étant donné une sous-expression e, l'expression views::enumerate(e) est équivalente à une expression à enumerate_view<views::all_t<decltype((e))>>(e) pour toute sous-expression appropriée e.3) Garantit que le type de référence du type sous-jacent peut être déplacé.
enumerate_view modélise les concepts random_access_range, bidirectional_range, forward_range, input_range, common_range, et sized_range lorsque la vue sous-jacente V modélise les concepts respectifs.
Membres de données
| Membre | Description |
V
base_
|
un itérateur vers le
view
sous-jacent
( membre d'objet d'exposition uniquement* ) |
Fonctions membres
construit un
enumerate_view
(fonction membre publique) |
|
|
retourne une copie de la vue sous-jacente (adaptée)
(fonction membre publique) |
|
|
retourne un itérateur vers le début
(fonction membre publique) |
|
|
retourne un itérateur ou un sentinelle vers la fin
(fonction membre publique) |
|
retourne le nombre d'éléments, fourni uniquement si la plage sous-jacente (adaptée) satisfait
sized_range
(fonction membre publique) |
|
|
(C++26)
|
retourne la taille approximative de la
approximately_sized_range
résultante
(fonction membre publique) |
Hérité de ranges::view_interface | |
| retourne si la vue dérivée est vide, seulement si elle satisfait sized_range ou forward_range (fonction membre publique de std::ranges::view_interface<D>)
| |
(C++23) |
retourne un itérateur constant vers le début de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
(C++23) |
retourne une sentinelle pour l'itérateur constant de la plage (fonction membre publique de std::ranges::view_interface<D>)
|
| retourne si la vue dérivée n'est pas vide, seulement si ranges::empty lui est applicable (fonction membre publique de std::ranges::view_interface<D>)
| |
| retourne le premier élément de la vue dérivée, à condition qu'elle satisfasse forward_range (fonction membre publique de std::ranges::view_interface<D>)
| |
| retourne le dernier élément de la vue dérivée, seulement si elle satisfait bidirectional_range et common_range (fonction membre publique de std::ranges::view_interface<D>)
| |
retourne le n-ième élément de la vue dérivée, seulement si elle satisfait random_access_range (fonction membre publique de std::ranges::view_interface<D>)
| |
Guides de déduction
Classes imbriquées
|
(C++23)
|
le type d'itérateur
( classe membre template d'exposition uniquement* ) |
|
(C++23)
|
le type de sentinelle
( classe membre template d'exposition uniquement* ) |
Modèles d'assistance
|
template
<
class
View
>
constexpr
bool
enable_borrowed_range
<
ranges
::
enumerate_view
<
View
>>
=
|
(depuis C++23) | |
Cette spécialisation de
ranges::enable_borrowed_range
permet à
enumerate_view
de satisfaire
borrowed_range
lorsque la vue sous-jacente la satisfait.
Notes
| Macro de test de fonctionnalité | Valeur | Std | Fonctionnalité |
|---|---|---|---|
__cpp_lib_ranges_enumerate
|
202302L
|
(C++23) |
std::ranges::enumerate_view
|
Exemple
Exécuter ce code
#include <initializer_list> #include <iostream> #include <map> #include <ranges> #include <vector> int main() { constexpr static auto v = {'A', 'B', 'C', 'D'}; for (auto const [index, letter] : std::views::enumerate(v)) std::cout << '(' << index << ':' << letter << ") "; std::cout << '\n'; #if __cpp_lib_ranges_to_container // créer une map utilisant la position de chaque élément comme clé auto m = v | std::views::enumerate | std::ranges::to<std::map>(); for (auto const [key, value] : m) std::cout << '[' << key << "]:" << value << ' '; std::cout << '\n'; #endif std::vector<int> numbers{1, 3, 5, 7}; // num est mutable même avec const, ce qui ne se propage pas à la référence // pour le rendre const, utiliser `std::views::enumerate(numbers) | std::views::as_const` // ou `std::views::enumerate(std::as_const(numbers))` for (auto const [index, num] : std::views::enumerate(numbers)) { ++num; // le type est int& std::cout << numbers[index] << ' '; } std::cout << '\n'; }
Sortie possible :
(0:A) (1:B) (2:C) (3:D) [0]:A [1]:B [2]:C [3]:D 2 4 6 8
Références
- Norme C++23 (ISO/CEI 14882:2024) :
-
- 26.7.23 Vue d'énumération [range.enumerate]
Voir aussi
|
(C++20)
|
une
view
constituée d'une séquence générée en incrémentant répétitivement une valeur initiale
(modèle de classe) (objet de point de personnalisation) |
|
(C++23)
|
une
view
constituée de tuples de références aux éléments correspondants des vues adaptées
(modèle de classe) (objet de point de personnalisation) |
prend une
view
constituée de valeurs
tuple-like
et un nombre N, et produit une
view
du N
ème
élément de chaque tuple
(modèle de classe) (objet adaptateur de plage) |