Namespaces
Variants

std::ranges:: subrange

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::subrange
Défini dans l'en-tête <ranges>
template <

std:: input_or_output_iterator I,
std:: sentinel_for < I > S = I,
ranges:: subrange_kind K = std:: sized_sentinel_for < S, I > ?
ranges :: subrange_kind :: sized :
ranges :: subrange_kind :: unsized >
requires ( K == ranges :: subrange_kind :: sized || ! std:: sized_sentinel_for < S, I > )
class subrange

: public ranges:: view_interface < subrange < I, S, K >>
(1) (depuis C++20)
Concepts auxiliaires
template < class From, class To >

concept /*uses-nonqualification-pointer-conversion*/ =

/* voir description */ ;
(2) ( exposition uniquement* )
template < class From, class To >
concept /*convertible-to-non-slicing*/ = /* voir description */ ;
(3) ( exposition uniquement* )
1) Le modèle de classe subrange combine un itérateur et un sentinelle en une seule view . Il modélise sized_range lorsque le dernier paramètre template est subrange_kind​ :: ​sized (ce qui se produit lorsque std:: sized_sentinel_for < S, I > est satisfait ou lorsque la taille est passée explicitement comme argument au constructeur).
2) Détermine si From est convertible en To sans conversions de qualification . Équivalent à : 
template<class From, class To>
concept /*uses-nonqualification-pointer-conversion*/ =
    std::is_pointer_v<From> && std::is_pointer_v<To> &&
        !std::convertible_to<std::remove_pointer_t<From>(*)[],
                             std::remove_pointer_t<To>(*)[]>;
3) Détermine si From est convertible en To sans conversion dérivée-vers-base : 
template<class From, class To>
concept /*convertible-to-non-slicing*/ =
    std::convertible_to<From, To> &&
        !/*uses-nonqualification-pointer-conversion*/
            <std::decay_t<From>, std::decay_t<To>>;

Table des matières

Membres de données

Membre Définition
constexpr bool StoreSize [static] K == ranges :: subrange_kind :: sized &&
! std:: sized_sentinel_for < S, I >
( constante membre statique d'exposition uniquement* )
I begin_ un itérateur vers le début du sous-intervalle
( objet membre d'exposition uniquement* )
S end_ un sentinelle dénotant la fin du sous-intervalle
( objet membre d'exposition uniquement* )
make-unsigned-like-t  < std:: iter_difference_t < I >> size_
(présent seulement si StoreSize est true ) 		la taille du sous-intervalle
( objet membre d'exposition uniquement* )

Fonctions membres

crée un nouveau subrange
(fonction membre publique)
convertit le subrange en un type pair-like
(fonction membre publique)
Observateurs
obtient l'itérateur
(fonction membre publique)
obtient le sentinelle
(fonction membre publique)
vérifie si le subrange est vide
(fonction membre publique)
obtient la taille du subrange
(fonction membre publique)
Opérations sur les itérateurs
avance l'itérateur d'une distance donnée
(fonction membre publique)
obtient une copie du subrange avec son itérateur décrémenté d'une distance donnée
(fonction membre publique)
obtient une copie du subrange avec son itérateur avancé d'une distance donnée
(fonction membre publique)
Hérité de std::ranges::view_interface
(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> )
retourne si la vue dérivée n'est pas vide, fourni seulement si ranges::empty lui est applicable
(fonction membre publique de std::ranges::view_interface<D> )
obtient l'adresse des données de la vue dérivée, fourni seulement si son type d'itérateur satisfait contiguous_iterator
(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 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, fourni seulement si elle satisfait random_access_range
(fonction membre publique de std::ranges::view_interface<D> )

Guides de déduction

Fonctions non membres

(C++20)
obtient un itérateur ou un sentinelle d'un std::ranges::subrange
(modèle de fonction)

Types auxiliaires

(C++20)
spécifie si un std::ranges::subrange modélise std::ranges::sized_range
(énumération)
(C++20)
obtient la taille d'un std::ranges::subrange
(spécialisation de modèle de classe)
(C++20)
obtient le type de l'itérateur ou du sentinelle d'un std::ranges::subrange
(spécialisation de modèle de classe)

Modèles d'assistance

template < class I, class S, ranges:: subrange_kind K >
constexpr bool ranges:: enable_borrowed_range < ranges :: subrange < I, S, K >> = true ;
(depuis C++20)

Cette spécialisation de ranges:: enable_borrowed_range permet à subrange de satisfaire borrowed_range .

Exemple

Exécuter ce code 
#include <map>
#include <print>
#include <ranges>
void make_uppercase(char& v)
{
    v += 'A' - 'a';
}
void uppercase_transform(std::multimap<int, char>& m, int k)
{
    auto [first, last] = m.equal_range(k);
    for (auto& [_, v] : std::ranges::subrange(first, last))
        make_uppercase(v);
}
int main()
{
    std::multimap<int, char> mm{{4, 'a'}, {3, '-'}, {4, 'b'}, {5, '-'}, {4, 'c'}};
    std::println("Before: {}", mm);
    uppercase_transform(mm, 4);
    std::println("After:  {}", mm);
}

Sortie : 

Before: {3: '-', 4: 'a', 4: 'b', 4: 'c', 5: '-'}
After:  {3: '-', 4: 'A', 4: 'B', 4: 'C', 5: '-'}

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 S'applique à Comportement publié Comportement corrigé
LWG 3470 C++20 convertible-to-non-slicing pourrait rejeter les conversions de qualification les accepte toujours

Voir aussi

(C++20)
classe modèle utilitaire pour définir une view , utilisant le curiously recurring template pattern
(classe modèle)

Liens externes

Lire/écrire toutes les valeurs d'une std::multimap avec une clé donnée en C++20 — SO