Namespaces
Variants
Views
Actions

std::ranges::filter_view<V,Pred>::iterator

From cppreference.com
< cpp‎ | ranges‎ | filter view
 
 
Ranges library
Range access
Range conversions
(C++23)
Range primitives



Dangling iterator handling
Range concepts
Views

Factories




Adaptors
Range generators
Range adaptor objects
Range adaptor closure objects
Helper items
 
 
class /*iterator*/;
(since C++20)

The return type of filter_view::begin. The name iterator is for exposition purposes only.

This is a bidirectional_iterator if V models bidirectional_range, a forward_iterator if V models forward_range, and input_iterator 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.

Contents

[edit] Member types

Member type Definition
iterator_concept
iterator_category

Defined if and only if V models forward_range. Let C be the type std::iterator_traits<ranges::iterator_t<V>>::iterator_category.

value_type ranges::range_value_t<V>
difference_type ranges::range_difference_t<V>

[edit] Data members

Typical implementations of iterator hold two non-static data members:

  • an iterator of type ranges::iterator_t<V> into the underlying view (shown here as current_ for exposition only), and
  • a pointer of type ranges::filter_view<V, Pred>* to the parent filter_view object (shown here as parent_ for exposition only).

[edit] Member functions

(constructor)
(C++20)
constructs an iterator
(public member function)
base
(C++20)
returns the underlying iterator
(public member function)
operator*operator->
(C++20)
forwards to the underlying iterator
(public member function)
operator++operator++(int)operator--operator--(int)
(C++20)
advances or decrements the iterator
(public member function)

std::ranges::filter_view::iterator::iterator

/*iterator*/()
  requires std::default_initializable<ranges::iterator_t<V>> = default;
(1) (since C++20)
constexpr /*iterator*/( filter_view& parent,
                        ranges::iterator_t<V> current );
(2) (since C++20)
1) Initializes current_ and parent_ with their default member initializers, which are = ranges::iterator_t<V>() and = nullptr respectively.
2) Initializes current_ with std::move(current) and parent_ with std::addressof(parent).

std::ranges::filter_view::iterator::base

constexpr const ranges::iterator_t<V>& base() const & noexcept;
(1) (since C++20)
constexpr ranges::iterator_t<V> base() &&;
(2) (since C++20)
1) Equivalent to return current_;.
2) Equivalent to return std::move(current_);.

std::ranges::filter_view::iterator::operator*,->

constexpr ranges::range_reference_t<V> operator*() const;
(1) (since C++20)
constexpr ranges::iterator_t<V> operator->() const

  requires /*has-arrow*/<ranges::iterator_t<V>> &&

           std::copyable<ranges::iterator_t<V>>;
(2) (since C++20)
1) Equivalent to return *current_;.
2) Equivalent to return current_;.
For a type I, /*has-arrow*/<I> is modeled or satisfied, if and only if I models or satisfies input_iterator respectively, and either I is a pointer type or requires(I i){ i.operator->(); } is true.

std::ranges::filter_view::iterator::operator++

constexpr /*iterator*/& operator++();
(1) (since C++20)
constexpr void operator++( int );
(2) (since C++20)
constexpr /*iterator*/ operator++( int )
  requires ranges::forward_range<V>;
(3) (since C++20)
1) Equivalent to
current_ = ranges::find_if(std::move(++current_), ranges::end(parent_->base_),

                           std::ref(*parent_->pred_));

return *this;
.
2) Equivalent to ++*this;.
3) Equivalent to auto tmp = *this; ++*this; return tmp;.

std::ranges::filter_view::iterator::operator--

constexpr /*iterator*/& operator--()
  requires ranges::bidirectional_range<V>;
(1) (since C++20)
constexpr /*iterator*/ operator--( int )
  requires ranges::bidirectional_range<V>;
(2) (since C++20)
1) Equivalent to
do

  --current_;
while (!std::invoke(*parent_->pred_, *current_));

return *this;
.
2) Equivalent to auto tmp = *this; --*this; return tmp;.

[edit] Non-member functions

operator==
(C++20)
compares the underlying iterators
(function)
iter_move
(C++20)
casts the result of dereferencing the underlying iterator to its associated rvalue reference type
(function)
iter_swap
(C++20)
swaps the objects pointed to by two underlying iterators
(function)

operator==(std::ranges::filter_view::iterator)

friend constexpr bool operator==( const /*iterator*/& x, const /*iterator*/& y )
  requires std::equality_comparable<ranges::iterator_t<V>>;
(since C++20)

Equivalent to return x.current_ == y.current_;.

The != operator is synthesized from operator==.

This function is not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when std::ranges::filter_view::iterator is an associated class of the arguments.

iter_move(std::ranges::filter_view::iterator)

friend constexpr ranges::range_rvalue_reference_t<V>

  iter_move( const /*iterator*/& i )

    noexcept(noexcept(ranges::iter_move(i.current_)));
(since C++20)

Equivalent to return ranges::iter_move(i.current_);.

This function is not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when std::ranges::filter_view::iterator is an associated class of the arguments.

iter_swap(std::ranges::filter_view::iterator)

friend constexpr void iter_swap( const /*iterator*/& x, const /*iterator*/& y )

  noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))

    requires std::indirectly_swappable<ranges::iterator_t<V>>;
(since C++20)

Equivalent to ranges::iter_swap(x.current_, y.current_).

This function is not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when std::ranges::filter_view::iterator is an associated class of the arguments.

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
P2259R1 C++20 member type iterator_category was always defined defined only if V is a forward_range
LWG 3533 C++20 the const& overload of base copied the underlying iterator returns a reference to it
LWG 3593 C++20 the const& overload of base might not be noexcept made noexcept