drop_while_view (Clase, Biblioteca estándar de C++)

Vista que contiene los elementos de un intervalo que permanecen una vez que se quitan los elementos iniciales que coinciden con un predicado.

Sintaxis

template<ranges::view V, class P>
    requires ranges::input_range<V> &&
             std::is_object_v<P> &&
             std::indirect_unary_predicate<const P, ranges::iterator_t<V>>
class drop_while_view : public ranges::view_interface<drop_while_view<V, P>>;

Parámetros de plantilla

V
Tipo de la vista subyacente.

P
Tipo del predicado que determina los elementos iniciales que se van a quitar.

Características de la vista

Para obtener una descripción de las siguientes entradas, vea View class characteristics (Ver características de clase).

Característica	Descripción
Adaptador de rango	views::drop_while
Intervalo subyacente	Debe satisfacer forward_range o superior y los iteradores del intervalo subyacente deben modelar sized_sentinel_for
Tipo de elemento	Igual que el intervalo subyacente
Ver categoría de iterador	Igual que el intervalo subyacente
Tamaño	Solo si el intervalo subyacente cumple random_access_range
Es const-iterable	No
Rango común	Solo si el intervalo subyacente cumple common_range
Intervalo prestado	Solo si el intervalo subyacente cumple borrowed_range

Miembros

Funciones miembro	Descripción
Constructores	Construya la vista.
base	Obtenga la vista subyacente.
begin	Obtenga un iterador al primer elemento.
end	Obtenga el sentinel al final de la vista.
pred	Obtiene una referencia al predicado que determina qué elementos se van a quitar.
Heredado de view_interface	Descripción
backC++20	Obtenga el último elemento.
dataC++20	Obtiene un puntero al primer elemento.
emptyC++20	Compruebe si la vista está vacía.
frontC++20	Obtiene el primer elemento.
operator[]C++20	Obtiene el elemento que se encuentra en la posición especificada.
operator boolC++20	Compruebe si la vista no está vacía.
size	Obtiene el número de elementos de la vista.

Requisitos

Encabezado: <ranges> (desde C++20)

Espacio de nombres: std::ranges

Opción del compilador: /std:c++20 o posterior es necesaria.

Constructores

Construya una instancia de .drop_while_view

1) constexpr drop_while_view(V base, P pred);
2) drop_while_view() requires default_initializable<V> && default_initializable<P> = default;

Parámetros

base
Intervalo subyacente.

pred
Predicado que determina los elementos iniciales que se van a quitar.

Para obtener información sobre los tipos de parámetros de plantilla, consulte Parámetros de plantilla.

Valor devuelto

Instancia de drop_while_view.

Comentarios

La mejor manera de crear un drop_while_view es usar el adaptador de views::drop_while rango. Los adaptadores de rango son la manera prevista de crear clases de vista. Los tipos de vista se exponen en caso de que desee crear su propio tipo de vista personalizado.

1) Move construye desde drop_while_view una base vista y un pred predicado. Tanto como base pred se mueven a través de std::move().
2) El valor predeterminado crea un drop_while_view.

Ejemplo: drop_while_view

// requires /std:c++20 or later
#include <ranges>
#include <vector>
#include <iostream>

void print(auto v)
{
    for (auto& x : v)
    {
        std::cout << x << ' ';
    }
    std::cout << '\n';
}

int main()
{
    std::vector<int> v{ 0, 1, 2, 3, -4, 5, 6 };
    auto myView = std::views::drop_while(
        v,
        [](int i) {return i >= 0; });
    print(myView); // -4 5 6

    auto myView2 = v | std::views::drop_while(
        [](int i) {return i < 5; });
    print(myView2); // 5 6
}

-4 5 6
5 6

base

Obtenga la vista subyacente.

// Uses a copy constructor to return the underlying view
constexpr V base() const& requires std::copy_constructible<V>;

// Uses std::move() to return the underlying view
constexpr V base() &&;

Parámetros

Ninguno.

Devoluciones

Vista subyacente.

begin

Obtenga un iterador al primer elemento de la vista.

constexpr auto begin();

Valor devuelto

Iterador que apunta al primer elemento de la vista. El comportamiento no está definido si la vista no tiene un predicado.

end

Obtenga el sentinel al final de la vista.

constexpr auto end()

Valor devuelto

Sentinel que sigue al último elemento de la vista:

pred

Obtenga una referencia al predicado que determina qué elementos iniciales se van a quitar.

constexpr const Pred& pred() const;

Valor devuelto

Referencia al predicado.

Comentarios

Si la vista no almacena un predicado, el comportamiento no está definido.

Por ejemplo, pred

// requires /std:c++20 or later
#include <ranges>
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v{ 0, 1, 2, 3, -4, 5, 6 };
    auto mv = v | std::views::drop_while(
        [](int i) {return i < 5; }); // drop the leading elements < 5
    std::cout << std::boolalpha << mv.pred()(v[6]); // outputs "false" because v[6] = 6 and 6 is not less than 5 (the predicate)
}

false

Consulte también

<ranges>
drop_while adaptador de rango
take_while adaptador de rango
take_while_view
ver clases