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
Definido en el encabezado <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) (desde C++20)
namespace views {

inline constexpr /* no especificado */ drop_while = /* no especificado */ ;

}
(2) (desde C++20)
Firma de llamada
template < ranges:: viewable_range R, class Pred >

requires /* ver más abajo */

constexpr ranges:: view auto drop_while ( R && r, Pred && pred ) ;
(desde C++20)
template < class Pred >
constexpr /*cierre adaptador de rango*/ drop_while ( Pred && pred ) ;
(desde C++20)
1) Un adaptador de rango que representa una view de elementos de una secuencia subyacente, comenzando en el primer elemento para el cual el predicado devuelve false .
2) RangeAdaptorObject . La expresión views :: drop_while ( e, f ) es equivalente-expresión a drop_while_view ( e, f ) para cualesquiera subexpresiones adecuadas e y f .

drop_while_view modela los conceptos contiguous_range , random_access_range , bidirectional_range , forward_range , input_range , y common_range cuando la vista subyacente V modela los respectivos conceptos. También modela sized_range si ranges:: forward_range < V > y std:: sized_sentinel_for < ranges:: sentinel_t < V > , ranges:: iterator_t < V >> están modelados.

Contenidos

Miembros de datos

Miembro Descripción
V base_ (privado) la vista subyacente
( objeto miembro solo para exposición* )
copyable-box <Pred> (hasta C++23) movable-box <Pred> (desde C++23) pred_ (privado) el objeto función subyacente
( objeto miembro solo para exposición* )
non-propagating-cache < ranges:: iterator_t < V >> cache_ (privado)
(presente solo si V satisface forward_range ) 		un objeto que almacena en caché el resultado de begin()
( objeto miembro solo para exposición* )

Funciones miembro

construye un drop_while_view
(función miembro pública)
devuelve una copia de la vista subyacente (adaptada)
(función miembro pública)
devuelve una referencia al predicado almacenado
(función miembro pública)
devuelve un iterador al inicio
(función miembro pública)
devuelve un iterador o un centinela al final
(función miembro pública)
Heredado de std::ranges::view_interface
devuelve si la vista derivada está vacía, proporcionado solo si satisface sized_range o forward_range
(función miembro pública de std::ranges::view_interface<D> )
(C++23)
devuelve un iterador constante al inicio del rango
(función miembro pública de std::ranges::view_interface<D> )
(C++23)
devuelve un centinela para el iterador constante del rango
(función miembro pública de std::ranges::view_interface<D> )
devuelve si la vista derivada no está vacía, proporcionado solo si ranges::empty es aplicable a ella
(función miembro pública de std::ranges::view_interface<D> )
obtiene la dirección de los datos de la vista derivada, proporcionado solo si su tipo de iterador satisface contiguous_iterator
(función miembro pública de std::ranges::view_interface<D> )
devuelve el número de elementos en la vista derivada. Proporcionado si satisface forward_range y su tipo de centinela e iterador satisfacen sized_sentinel_for .
(función miembro pública de std::ranges::view_interface<D> )
devuelve el primer elemento en la vista derivada, proporcionado si satisface forward_range
(función miembro pública de std::ranges::view_interface<D> )
devuelve el último elemento en la vista derivada, proporcionado solo si satisface bidirectional_range y common_range
(función miembro pública de std::ranges::view_interface<D> )
devuelve el n ésimo elemento en la vista derivada, proporcionado solo si satisface random_access_range
(función miembro pública de std::ranges::view_interface<D> )

Guías de deducción

Plantillas auxiliares

template < class T, class Pred >

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

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

Esta especialización de std :: ranges:: enable_borrowed_range hace que drop_while_view cumpla con borrowed_range cuando la vista subyacente lo satisface.

Notas

Para proporcionar la complejidad temporal amortizada constante requerida por el concepto range , el resultado de begin se almacena en caché dentro del objeto drop_while_view . Si el rango subyacente se modifica después de la primera llamada a begin() , los usos posteriores del objeto drop_while_view podrían tener un comportamiento no intuitivo.

Ejemplo

Ejecutar este código 
#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';
}

Salida: 

3 4 5

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3494 C++20 drop_while_view nunca fue un borrowed_range es un borrowed_range si su vista subyacente lo es

Véase también

(C++20)
una view que consiste en elementos de otra view , omitiendo los primeros N elementos
(plantilla de clase) (objeto adaptador de rango)