Namespaces
Variants

std::ranges:: views:: drop_while, std::ranges:: drop_while_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::drop_while_view
Défini dans l'en-tête <ranges>
template < ranges:: view V, class Pred >

requires ranges:: input_range < V > &&
std:: is_object_v < Pred > &&
std:: indirect_unary_predicate < const Pred, ranges:: iterator_t < V >>
class drop_while_view

: public ranges:: view_interface < drop_while_view < V, Pred >>
(1) (depuis C++20)
namespace views {

inline constexpr /* non spécifié */ drop_while = /* non spécifié */ ;

}
(2) (depuis C++20)
Signature d'appel
template < ranges:: viewable_range R, class Pred >

requires /* voir ci-dessous */

constexpr ranges:: view auto drop_while ( R && r, Pred && pred ) ;
(depuis C++20)
template < class Pred >
constexpr /*adaptateur de plage de fermeture*/ drop_while ( Pred && pred ) ;
(depuis C++20)
1) Un adaptateur de gamme qui représente view d'éléments d'une séquence sous-jacente, commençant au premier élément pour lequel le prédicat retourne false .
2) RangeAdaptorObject . L'expression views :: drop_while ( e, f ) est équivalente en expression à drop_while_view ( e, f ) pour toutes sous-expressions appropriées e et f .

drop_while_view modélise les concepts contiguous_range , random_access_range , bidirectional_range , forward_range , input_range , et common_range lorsque la vue sous-jacente V modélise les concepts respectifs. Elle modélise également sized_range si ranges:: forward_range < V > et std:: sized_sentinel_for < ranges:: sentinel_t < V > , ranges:: iterator_t < V >> sont modélisés.

Table des matières

Membres de données

Membre Description
V base_ (privé) la vue sous-jacente
( objet membre d'exposition uniquement* )
copyable-box <Pred> (jusqu'à C++23) movable-box <Pred> (depuis C++23) pred_ (privé) l'objet fonction sous-jacent
( objet membre d'exposition uniquement* )
non-propagating-cache < ranges:: iterator_t < V >> cache_ (privé)
(présent uniquement si V satisfait forward_range ) 		un objet qui met en cache le résultat de begin()
( objet membre d'exposition uniquement* )

Fonctions membres

construit un drop_while_view
(fonction membre publique)
retourne une copie de la vue sous-jacente (adaptée)
(fonction membre publique)
retourne une référence au prédicat stocké
(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)
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> )
obtient l'adresse des données de la vue dérivée, fourni uniquement si son type d'itérateur satisfait contiguous_iterator
(fonction membre publique de std::ranges::view_interface<D> )
retourne le nombre d'éléments dans la vue dérivée. Fourni si elle satisfait forward_range et que son type de sentinelle et d'itérateur satisfont sized_sentinel_for .
(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

Modèles d'assistance

template < class T, class Pred >

constexpr bool enable_borrowed_range < std :: ranges :: drop_while_view < T, Pred >> =

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

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

Notes

Afin de fournir la complexité temporelle amortie constante requise par le concept range , le résultat de begin est mis en cache dans l'objet drop_while_view . Si la plage sous-jacente est modifiée après le premier appel à begin() , les utilisations ultérieures de l'objet drop_while_view pourraient présenter un comportement non intuitif.

Exemple

Exécuter ce code 
#include <iostream>
#include <ranges>
#include <string>
#include <string_view>
using std::operator""sv;
[[nodiscard]]
constexpr bool is_space(char p) noexcept
{
    auto ne = [p](auto q) { return p != q; };
    return !!(" \t\n\v\r\f" | std::views::drop_while(ne));
};
[[nodiscard("trims the output")]]
constexpr std::string_view trim_left(std::string_view const in) noexcept
{
    auto view = in | std::views::drop_while(is_space);
    return {view.begin(), view.end()};
}
[[nodiscard("trims the output")]]
constexpr std::string trim(std::string_view const in)
{
    auto view = in
              | std::views::drop_while(is_space)
              | std::views::reverse
              | std::views::drop_while(is_space)
              | std::views::reverse
              ;
    return {view.begin(), view.end()};
}
int main()
{
    static_assert(trim_left(" \n C++23") == "C++23"sv);
    constexpr auto src{" \f\n\t\r\vHello, C++20!\f\n\t\r\v "sv};
    static_assert(trim(src) == "Hello, C++20!");
    static constexpr auto v = {0, 1, 2, 3, 4, 5};
    for (int n : v | std::views::drop_while([](int i) { return i < 3; }))
        std::cout << n << ' ';
    std::cout << '\n';
}

Sortie : 

3 4 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 Applicable à Comportement publié Comportement corrigé
LWG 3494 C++20 drop_while_view n'était jamais un borrowed_range c'est un borrowed_range si sa vue sous-jacente l'est

Voir aussi

(C++20)
une view constituée d'éléments d'une autre view , ignorant les N premiers éléments
(modèle de classe) (objet adaptateur de gamme)