std::ranges::view::filter, std::ranges::filter_view
| template< InputRange V, IndirectUnaryPredicate<iterator_t<V>> Pred > requires View<V> && std::is_object_v<Pred> |
(1) | (since C++20) |
| namespace view { inline constexpr /*unspecified*/ filter = /*unspecified*/; |
(2) | (since C++20) |
View of an underlying sequence without the elements that fail to satisfy a predicate.filter_view models the concepts BidirectionalRange, ForwardRange, InputRange, and CommonRange when the underlying view V models respective concepts.
Data members
std::ranges::filter_view::base_
| V base_ = V(); /* exposition-only */ |
||
the underlying view
std::ranges::filter_view::pred_
| semiregular<Pred> pred_; /* exposition-only */ |
||
the predicate used to filter out elements of base_
semiregular is a wrapper class template which behaves exactly like std::optional except for some small differences. The name semiregular is for exposition purposes only and not normative.
Member functions
std::ranges::filter_view::filter_view
| filter_view() = default; |
(1) | |
| constexpr filter_view(V base, Pred pred); |
(2) | |
| template<InputRange R> requires ViewableRange<R> && Constructible<V, all_view<R>> |
(3) | |
base_ and pred_base_ with std::move(base) and initializes pred_ with std::move(pred).base_ with view::all(std::forward<R>(r)) and initializes pred_ with std::move(pred).Parameters
| r | - | range to filter |
| pred | - | predicate to filter out elements |
std::ranges::filter_view::base
| constexpr V base() const; |
||
Equivalent to return base_;
std::ranges::filter_view::begin
| constexpr iterator begin(); |
||
Returns the iterator initialized with {*this, ranges::find_if(base_, std::ref(*pred_))}. In order to provide the amortized constant time complexity required by the Range concept, this function caches the result within the filter_view object for use on subsequent calls.
The behavior is undefined unless pred_.has_value()
std::ranges::filter_view::end
| constexpr auto end() { if constexpr (CommonRange<V>) |
||
Deduction guides
| template<class R, class Pred> filter_view(R&&, Pred) -> filter_view<all_view<R>, Pred>; |
||
Nested classes
std::ranges::filter_view::iterator
| template<class V, class Pred> class filter_view<V, Pred>::iterator /* exposition-only */ |
||
The return type of filter_view::begin.
This is a BidirectionalIterator if V models BidirectionalRange, a ForwardIterator if V models ForwardRange, and InputIterator otherwise.
Modification of the element denoted by this iterator is permitted, but results in undefined behavior if the resulting value does not satisfy the filter's predicate.
std::ranges::filter_view::iterator::iterator
| iterator() = default; constexpr iterator(filter_view& parent, iterator_t<V> current); |
||
Initializes exposition-only data member current_ with current and exposition-only data members parent_ with addressof(parent).
std::ranges::filter_view::iterator::operator++
| constexpr iterator& operator++() |
||
Equivalent to
current_ = ranges::find_if(++current_, ranges::end(parent_->base_), ref(*parent_->pred_)); return *this;
std::ranges::filter_view::iterator::operator--
| constexpr iterator& operator--() requires BidirectionalRange<V>; |
||
Equivalent to
do --current_; while (!invoke(*parent_->pred_, *current_)); return *this;
Other members as expected of an iterator.
std::ranges::filter_view::sentinel
| template<class V, class Pred> class filter_view<V, Pred>::sentinel /* exposition-only */ |
||
The return type of filter_view::end.
std::ranges::filter_view::sentinel::end_
| sentinel_t<V> end_ = sentinel_t<V>(); /* exposition only */ |
||
Exposition-only data member holding the sentinel of the underlying View.
std::ranges::filter_view::sentinel::sentinel
| sentinel() = default; constexpr explicit sentinel(filter_view& parent); |
||
Initializes exposition-only data member end_ with parent.
std::ranges::filter_view::sentinel::base
| constexpr sentinel_t<V> base() const; |
||
Equivalent to: return end_;
std::ranges::filter_view::sentinel::operator==
| friend constexpr bool operator==(const iterator& x, const sentinel& y); friend constexpr bool operator==(const sentinel& x, const iterator& y); |
||
Equivalent to: return x.current_ == y.end_; and return y == x; respectively.
std::ranges::filter_view::sentinel::operator!=
| friend constexpr bool operator!=(const iterator& x, const sentinel& y); friend constexpr bool operator!=(const sentinel& x, const iterator& y); |
||
Equivalent to return !(x == y); and return !(y == x); respectively
Example
#include <vector> #include <ranges> #include <iostream> int main() { std::vector<int> ints{0,1,2,3,4,5}; auto even = [](int i){ return 0 == i % 2; }; auto square = [](int i) { return i * i; }; for (int i : ints | std::view::filter(even) | std::view::transform(square)) { std::cout << i << ' '; } }
Output:
0 4 16