Namespaces
Variants

std::ranges:: views:: enumerate, std::ranges:: enumerate_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::enumerate_view
Member functions
(C++26)
Deduction guides
Nested classes
Iterator
Sentinel
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 /* non spécifié */ enumerate = /* non spécifié */ ;

}
(2) (depuis C++23)
Signature d'appel
template < ranges:: viewable_range R >

requires /* voir ci-dessous */

constexpr /* voir ci-dessous */ enumerate ( R && r ) ;
(depuis C++23)
Concepts auxiliaires
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) ( exposition uniquement* )
1) enumerate_view est un adaptateur de gamme qui prend une view et produit une vue de tuple s. Le 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ée une sous-expression e , l'expression views :: enumerate ( e ) est expression-équivalente à 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.

Table des matières

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 std::ranges::view_interface
indique si la vue dérivée est vide, fourni uniquement 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 un sentinelle pour l'itérateur constant de la plage
(fonction membre publique de std::ranges::view_interface<D> )
indique 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> )
retourne le premier élément de la vue dérivée, fourni si elle satisfait forward_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le dernier élément de la vue dérivée, fourni uniquement si elle satisfait bidirectional_range et common_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le n ème élément de 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

(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 >> =

ranges:: enable_borrowed_range < 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)
(C++20)
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)