Namespaces
Variants

    std::ranges::views::drop, std::ranges::drop_view

    De fr.cppreference.net
     
    C++
    Support du compilateur
    Indépendant et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support du langage
    Bibliothèque des concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque des itérateurs
    Bibliothèque des plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes de caractères
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque de système de fichiers (C++17)
    Bibliothèque de support de concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque des plages
    Adaptateurs de plage
     
    std::ranges::drop_view
     
    Défini dans l'en-tête <ranges> 
    template< ranges::view V >
class drop_view
    : public ranges::view_interface<drop_view<V>>
    		(1) (depuis C++20) 
    namespace views {
    inline constexpr /* unspecified */ drop = /* unspecified */;
}
    		(2) (depuis C++20)
    Signature d'appel
    		 
    template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto
    drop( R&& r, ranges::range_difference_t<R> count );
    		(depuis C++20) 
    template< class DifferenceType >
constexpr /* range adaptor closure */ drop( DifferenceType&& count );
    		(depuis C++20)
    1) Un adaptateur de plage composé des éléments de la séquence sous-jacente, ignorant les N premiers éléments.
    2) RangeAdaptorObject. Soit T est std::remove_cvref_t<decltype((e))> et D est ranges::range_difference_t<decltype((e))>), l'expression views::drop(e, f) est équivalente en expression à :
    • ((void)f, decay-copy(e)), si T est un ranges::empty_view, sauf que les évaluations de e et f sont séquencées de manière indéterminée ;
    • sinon, T(ranges::begin(e) + inc, ranges::end(e),
      /*to-unsigned-like*/(ranges::distance(e) - inc))      , si T est une spécialisation de ranges::subrange qui modélise à la fois random_access_range et sized_range, et T a besoin de stocker la taille (voir ranges::subrange::subrange() pour plus de détails), où inc est std::min<D>(ranges::distance(e), f) ;
    • sinon, U(ranges::begin(e) + inc, ranges::end(e)), si T est une spécialisation de std::span, std::basic_string_view, ranges::iota_view, ou ranges::subrange qui modélise à la fois random_access_range et sized_range, où U est
    • std::span<typename T::element_type>, si T est une spécialisation de std::span ;
    • T sinon ;
    • views::repeat(*e.value_, ranges::distance(e) - inc), si T modélise sized_range ; dans ce cas e n'est évalué qu'une seule fois ;
    • ((void)e, auto(f)) sinon, sauf que les évaluations de e et f sont séquencées de manière indéterminée ;
    		 (depuis C++23)
    • sinon, drop_view(e, f).
    Dans tous les cas, decltype((f)) doit modéliser std::convertible_to<D>.

    drop_view modélise les concepts contiguous_range, 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_ (privé) la vue sous-jacente
    (exposition-only member object*)
    ranges::range_difference_t<V> count_ (privé) le nombre d'éléments à ignorer
    (exposition-only member object*)
    cache non propagateur<ranges::iterator_t<V>> cache_ (privé)
    (présent uniquement si V satisfait à forward_range
    mais pas random_access_range et sized_range)         		un objet qui met en cache le résultat des appels à begin()
    (exposition-only member object*)

    Fonctions membres

    		construit un drop_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
    		renvoie si la vue dérivée est vide, à condition qu'elle satisfasse sized_range ou forward_range
    (fonction membre publique de std::ranges::view_interface<D>)
    (C++23)
    		 renvoie un itérateur constant vers le début de la plage
    (fonction membre publique de std::ranges::view_interface<D>)
    (C++23)
    		 renvoie une 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, à condition que ranges::empty lui soit applicable
    (fonction membre publique de std::ranges::view_interface<D>)
    		obtient l'adresse des données de la vue dérivée, à condition que son type d'itérateur satisfasse contiguous_iterator
    (fonction membre publique de std::ranges::view_interface<D>)
    		renvoie 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>)
    		renvoie le dernier élément de la vue dérivée, à condition qu'elle satisfasse bidirectional_range et common_range
    (fonction membre publique de std::ranges::view_interface<D>)
    		renvoie le nième élément dans la vue dérivée, à condition qu'elle satisfasse random_access_range
    (fonction membre publique de std::ranges::view_interface<D>)

    Guides de déduction

    Modèles d'assistance

    template < class T >

    constexpr bool enable_borrowed_range < std :: ranges :: drop_view < T >> =

    ranges:: enable_borrowed_range < T > ;
    		(depuis C++20)

    Cette spécialisation de ranges::enable_borrowed_range permet à drop_view de satisfaire borrowed_range lorsque la vue sous-jacente la satisfait.

    Exemple

    Exécuter ce code 
    #include <initializer_list>
#include <iostream>
#include <ranges>
int main()
{
    const auto nums = {1, 2, 3, 4, 5, 6, 7};
    std::cout << "drop " << 2 << ": ";
    for (int i : std::ranges::drop_view{nums, 2})
        std::cout << i << ' ';
    std::cout << '\n';
    std::cout << "drop " << 3 << ": ";
    for (int i : nums | std::views::drop(3))
        std::cout << i << ' ';
    std::cout << '\n';
    std::cout << "drop " << 4 << ": ";
    for (int i : std::views::iota(1, 8) | std::views::drop(4))
        std::cout << i << ' ';
    std::cout << '\n';
    // Notez que supprimer plus d'éléments que le nombre total est acceptable :
    for (int dp : {5, 6, 7, 890, 100500})
    {
        std::cout << "drop " << dp << ": ";
        for (int i : std::views::iota(1, 8) | std::views::drop(dp))
            std::cout << i << ' ';
        std::cout << '\n';
    }
}

    Sortie : 

    drop 2: 3 4 5 6 7
drop 3: 4 5 6 7
drop 4: 5 6 7
drop 5: 6 7
drop 6: 7
drop 7:
drop 890: 
drop 100500:

    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 3407 C++20 views::drop échoue parfois à
    construire une plage à accès aléatoire dimensionnée     		la construction est ajustée
    pour qu'elle soit toujours valide
    LWG 3494 C++20 drop_view n'était jamais une borrowed_range c'est une borrowed_range si sa vue sous-jacente l'est

    Voir aussi

    (C++20)
    		une view constituée des éléments d'une autre view , ignorant la sous-séquence initiale des éléments jusqu'au premier élément où le prédicat retourne false
    (modèle de classe) (objet adaptateur de gamme)