take_while_view (Clase, Biblioteca estándar de C++)
Vista que contiene los elementos iniciales de un intervalo que coinciden con un predicado.
Sintaxis
template<view V, class Pred> requires
input_range<V> && is_object_v<Pred> &&
indirect_unary_predicate<const Pred, iterator_t<V>>
class take_while_view : public view_interface<take_while_view<V, Pred>>;
Parámetros de plantilla
Pred
Tipo del predicado que determina los elementos iniciales que se van a colocar en la vista.
V
Tipo de la vista subyacente.
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::take_while |
| Intervalo subyacente | Debe satisfacer input_range o superior |
| Tipo de elemento | Igual que el intervalo subyacente |
| Ver categoría de iterador | Igual que el intervalo subyacente |
| Tamaño | No |
Es const-iterable |
Solo si el intervalo subyacente es const iterable y el predicado puede funcionar con const referencias. |
| Rango común | No |
| Intervalo prestado | No |
Miembros
| Funciones miembro | Descripción |
|---|---|
| ConstructoresC++20 | Construya la vista. |
baseC++20 |
Obtenga el intervalo subyacente. |
beginC++20 |
Obtenga un iterador al primer elemento. |
endC++20 |
Obtenga el sentinel al final de la vista. |
predC++20 |
Obtenga una referencia al predicado que determina qué elementos se van a tomar. |
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
Construcción de una instancia de take_while_view
1) take_while_view() requires
default_initializable<V> &&
default_initializable<Pred> = default;
2) constexpr take_while_view(V base, Pred pred);
Parámetros
base
Vista subyacente.
pred
Predicado que determina los elementos iniciales que se van a colocar en la vista.
Para obtener información sobre los tipos de parámetros de plantilla, consulte Parámetros de plantilla.
Valor devuelto
Un objeto take_while_view.
Comentarios
La mejor manera de crear un take_while_view es usar el adaptador de views::take_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 take_while_view una base vista y un pred predicado. Tanto como base pred se mueven a través de std::move().
2) Construye un vacío take_while_view. La vista subyacente y el predicado se construyen de forma predeterminada.
Ejemplo: take_while_view
// 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 twv = std::views::take_while(v, [](int i) {return i >= 0; });
for (auto& e : twv)
{
std::cout << e << ' '; // 0 1 2 3
}
std::cout << '\n';
// Using the '|' operator to create a take_view
for (auto i : v | std::views::take_while([](int i) {return i < 5; }))
{
std::cout << i << ' '; // 0 1 2 3 -4
}
}
0 1 2 3
0 1 2 3 -4
base
Obtiene una copia de la vista subyacente.
// Uses a copy constructor to return the underlying view
1) constexpr V base() const& requires std::copy_constructible<V>;
// Uses a move constructor to return the underlying view
2) constexpr V base() &&;
Parámetros
Ninguno.
Devoluciones
Copia de la vista subyacente.
begin
Obtenga un iterador al primer elemento de la vista.
1) constexpr auto begin() requires (!Simple_view<V>);
2) constexpr auto begin() const requires
range<const V> &&
indirect_unary_predicate<const Pred, iterator_t<const V>>
Parámetros
Ninguno.
Valor devuelto
Iterador que apunta al primer elemento de la vista. El comportamiento no está definido si la vista no tiene un predicado.
Comentarios
Para 1, el Simple_view requisito significa que una vista V y const V tienen los mismos tipos de iterador y centinela.
end
Obtenga el sentinel al final de la vista.
1) constexpr auto end() requires (!Simple_view<V>);
2) constexpr auto end() const requires
range<const V> &&
indirect_unary_predicate<const Pred, iterator_t<const V>
Parámetros
Ninguno.
Valor devuelto
Sentinel que sigue al último elemento de la vista.
Comentarios
Para 1, el Simple_view requisito significa que una vista V y const V tienen los mismos tipos de iterador y centinela.
pred
Obtenga una referencia al predicado usado para seleccionar qué elementos iniciales irán en la vista.
constexpr const Pred& pred() const;
Valor devuelto
Referencia al predicado usado para seleccionar los elementos iniciales que se van a colocar en la vista.
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::take_while(
[](int i) {return i < 5; });
std::cout << std::boolalpha << mv.pred()(v[6]); // outputs false because v[6] = 6 and 6 is not less than 5 (the predicate)
}