std::ranges::views::filter, std::ranges::filter_view

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de rangos

Acceso a rangos begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata empty

Conversiones de rangos std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Manejo de iteradores pendientes dangling borrowed_iterator_t borrowed_subrange_t

Primitivas de rangos
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Conceptos de rangos
range borrowed_range    sized_range	common_range view viewable_range	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	constant_range (C++23)

Vistas
view_interface	subrange

Fábricas de rangos
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Adaptadores de rangos
views::all_tviews::all ref_view owning_view as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while concat_viewviews::concat (C++26)(C++26) views::counted	drop_viewviews::drop drop_while_viewviews::drop_while join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   lazy_split_viewviews::lazy_split split_viewviews::split common_viewviews::common cache_latest_viewviews::cache_latest (C++26)(C++26)	reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Generadores de rangos std::generator (C++23)

Objetos cierre adaptadores de rangos range_adaptor_closure (C++23)

Objetos adaptadores de rangos

Elementos auxiliares
copyable-box movable-box (hasta C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::filter_view

Funciones miembro

filter_view::filter_view (C++20)

filter_view::base (C++20)

filter_view::pred (C++20)

filter_view::begin (C++20)

filter_view::end (C++20)

Guías de deducción (C++20)

Iterador

filter_view::iterator::iterator (C++20)

filter_view::iterator::base (C++20)

filter_view::iterator::operator*filter_view::iterator::operator-> (C++20)(C++20)

filter_view::iterator::operator++ filter_view::iterator::operator++(int) (C++20)(C++20)

filter_view::iterator::operator-- filter_view::iterator::operator--(int) (C++20)(C++20)

operator==(filter_view::iterator) (C++20)

iter_move(filter_view::iterator) (C++20)

iter_swap(filter_view::iterator) (C++20)

Centinela

filter_view::sentinel::sentinel (C++20)

filter_view::sentinel::base (C++20)

operator==(filter_view::iterator, filter_view::sentinel) (C++20)

 

Definido en el archivo de encabezado <ranges>
template< ranges::input_range V, std::indirect_unary_predicate<ranges::iterator_t<V>> Pred > requires ranges::view<V> && std::is_object_v<Pred> class filter_view : public ranges::view_interface<filter_view<V, Pred>>	(1)	(desde C++20)
namespace views { inline constexpr /*no especificado*/ filter = /*no especificado*/; }	(2)	(desde C++20)
Signatura de la llamada
template< ranges::viewable_range R, class Pred > requires /* véase a continuación */ constexpr ranges::view auto filter( R&& r, Pred&& pred );		(desde C++20)
template< class Pred > constexpr /*cierre de adaptador de rango*/ filter( Pred&& pred );		(desde C++20)

1) Un adaptador de rango que representa una vista (view) de una secuencia subyacente sin los elementos que no satisfacen un predicado.

2) Objeto adaptador de rangot. La expresión views::filter(e, p) es equivalente en expresión a filter_view(e, p) para cualquier subexpresión e y p adecuadas.

filter_view modela los conceptos bidirectional_range, forward_range, input_range, y common_range cuando la vista subyacente V modela los conceptos respectivos.

Equivalente en expresión

La expresión e es equivalente-en-expresión a la expresión f, si e y f tienen los mismos efectos, ambas potencialmente lanzan o ambas potencialmente no lanzan (es decir, noexcept (e) == noexcept(f)), y ambas son subexpresiones constantes o ambas no son subexpresiones constantes.

Datos miembro

Las implementaciones típicas de filter_view albergan dos o tres datos miembro no estáticos:

• la vista subyacente de tipo V (que aquí se muestra como base_ solo de exposición),
• un envoltorio que envuelve el predicado utilizado para filtrar los elementos de base_ de tipo /*copyable-box*/<Pred> (que aquí se muestra como pred_ solo de exposición), donde copyable-box es una plantilla de clase envoltorio que siempre satisface copyable,
• un objeto de tipo similar a std::optional (que aquí se muestra como begin_ solo de exposición) que almacena en caché un iterador al primer elemento de base_ que satisface el predicado pred_. begin_ puede estar presente solo si filter_view modela forward_range.

Funciones miembro

(constructor) (C++20)	Construye un objeto filter_view. (función miembro pública)
base (C++20)	Devuelve la vista subyacente V . (función miembro pública)
pred (C++20)	Devuelve una referencia al predicado almacenado dentro de la vista filter_view. (función miembro pública)
begin (C++20)	Devuelve el iterador al comienzo de la vista filter_view. (función miembro pública)
end (C++20)	Devuelve el centinela de la vista filter_view. (función miembro pública)
Heredadas de std::ranges::view_interface
empty (C++20)	Devuelve si la vista derivada está vacía o no. Se proporciona si la vista derivada satisface forward_range. (función miembro pública de std::ranges::view_interface<D>)
operator bool (C++20)	Devuelve si la vista derivada está vacía o no. Se proporciona si ranges::empty le es aplicable. (función miembro pública de std::ranges::view_interface<D>)
front (C++20)	Devuelve el primer elemento en la vista derivada. Se proporciona si la vista derivada satisface forward_range. (función miembro pública de std::ranges::view_interface<D>)
back (C++20)	Devuelve el último elemento en una vista derivada. Se proporciona si la vista derivada satisface bidirectional_range y common_range. (función miembro pública de std::ranges::view_interface<D>)

std::ranges::filter_view::filter_view

filter_view() requires std::default_initializable<V> && std::default_initializable<Pred> = default;	(1)	(desde C++20)
constexpr filter_view( V base, Pred pred );	(2)	(desde C++20)

1) Inicializa por valor a base_ mediante su inicializador de miembro por defecto (= V()) e inicializa por defecto a pred_ (lo que inicializa por valor al predicado Pred contenido).

2) Inicializa a base_ con std::move(base) e inicializa a pred_ con std::move(pred).

Parámetros

base	-	Rango a filtrar.
pred	-	Predicado del que filtrar elementos.

std::ranges::filter_view::base

constexpr V base() const& requires std::copy_constructible<V>;	(1)	(desde C++20)
constexpr V base() &&;	(2)	(desde C++20)

1) Equivalente a return base_;.

2) Equivalente a return std::move(base_);.

std::ranges::filter_view::pred

constexpr const Pred& pred() const;		(desde C++20)

Devuelve una referencia al objeto predicado Pred contenido. El comportamiento no está definido si pred_ no contiene un valor.

std::ranges::filter_view::begin

constexpr /*iterador*/ begin();		(desde C++20)

Para proporcionar la complejidad de tiempo constante amortizada requerida por el concepto range, esta función almacena en caché el resultado dentro del objeto filter_view para usarlo en llamadas posteriores. Equivalente a

if constexpr (!ranges::forward_range<V>) {
    return /*iterador*/{*this, ranges::find_if(base_, std::ref(*pred_))};
} else {
    if (!begin_.has_value())
        begin_ = ranges::find_if(base_, std::ref(*pred_)); // almacena en caché
    return /*iterador*/{*this, begin_.value())};
}

El comportamiento no está definido si pred_ no contiene un valor.

std::ranges::filter_view::end

constexpr auto end() { if constexpr (ranges::common_range<V>) return /*iterador*/{*this, ranges::end(base_)}; else return /*centinela*/{*this}; }		(desde C++20)

Guías de deducción

template< class R, class Pred > filter_view( R&&, Pred ) -> filter_view<views::all_t<R>, Pred>;		(desde C++20)

Clases anidadas

iterator (C++20)	El tipo iterador de filter_view. (clase miembro de solo exposición)
sentinel (C++20)	El tipo centinela de filter_view cuando la vista subyacente no es un common_range (clase miembro de solo exposición)

Ejemplo

Ejecuta este código

#include <iostream>
#include <ranges>

int main() {
    auto even = [](int i) { return 0 == i % 2; };
    auto square = [](int i) { return i * i; };
 
    for (int i : std::views::iota(0, 6) 
               | std::views::filter(even) 
               | std::views::transform(square)) {
        std::cout << i << ' ';
    }
}

Salida:

0 4 16

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
P2325R3	C++20	Si Pred no es default_initializable, el constructor por defecto construye una vista filter_view que no contiene un predicado Pred.	La vista filter_view tampoco es default_initializable.

Véase también

ranges::take_while_viewviews::take_while (C++20)

Una vista (view) que consiste en los elementos iniciales de otra vista, hasta el primer elemento sobre el que un predicado devuelva falso. (plantilla de clase) (objeto adaptador de rango)