◐ Shell
clean mode source ↗

std::ranges::views::filter, std::ranges::filter_view - cppreference.com

De cppreference.com

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 ranges::view_interface

(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>) [editar]
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>) [editar]

(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>) [editar]

(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>) [editar]

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

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

Ejemplo

#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:

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