NAME¶

std::ranges::split_view::iterator - std::ranges::split_view::iterator

Synopsis¶

class /*iterator*/; (since C++20)
(exposition only*)

The return type of split_view::begin. This is a forward_iterator, so it is expected
that V models at least forward_range.

Member types¶

Member type Definition
iterator_concept std::forward_iterator_tag
iterator_category std::input_iterator_tag
value_type ranges::subrange<ranges::iterator_t<V>>
difference_type ranges::range_difference_t<V>

Data members

Member name Definition
A pointer of type ranges::split_view<V, Pattern>* to the
parent_ (private) parent split_view object.
(exposition-only member object*)
An iterator of type ranges::iterator_t<V> into the
cur_ (private) underlying view that points to the begin of a current
subrange.
(exposition-only member object*)
A subrange of type ranges::subrange<ranges::iterator_t<V>>
next_ (private) to the position of the pattern next to the current
subrange.
(exposition-only member object*)
A boolean flag that indicates whether an empty trailing
trailing_empty_ (private) subrange (if any) was reached.
(exposition-only member object*)

Member functions¶

constructor constructs an iterator
(C++20) (public member function)
base returns the underlying iterator
(C++20) (public member function)
operator* returns the current subrange
(C++20) (public member function)
operator++ advances the iterator
operator++(int) (public member function)
(C++20)

std::ranges::split_view::iterator::iterator

/*iterator*/() = default; (1) (since C++20)
constexpr /*iterator*/( split_view& parent, ranges::iterator_t<V>
current, (2) (since C++20)
ranges::subrange<ranges::iterator_t<V>>
next );

1) Value-initializes non-static data members with their default member initializers,
that is
* ranges::split_view* parent_ = nullptr;,
* ranges::iterator_t<V> cur_ = ranges::iterator_t<V>();,
* ranges::subrange<ranges::iterator_t<V>> next_ =
ranges::subrange<ranges::iterator_t<V>>();, and
* bool trailing_empty_ = false;.
2) Initializes non-static data members:
* ranges::split_view* parent_ = std::addressof(parent);,
* ranges::iterator_t<V> cur_ = std::move(current);,
* ranges::subrange<ranges::iterator_t<V>> next_ = std::move(next);, and
* bool trailing_empty_ = false;.

std::ranges::split_view::iterator::base

constexpr const ranges::iterator_t<V> base() const; (since C++20)

Equivalent to return cur_;.

std::ranges::split_view::iterator::operator*

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

Equivalent to return {cur_, next_.begin()};.

std::ranges::split_view::iterator::operator++

constexpr /*iterator*/& operator++(); (1) (since C++20)
constexpr void operator++( int ); (2) (since C++20)

1) Equivalent to
cur_ = next_.begin();

if (cur_ != ranges::end(parent_->base_))
{
if (cur_ = next_.end(); cur_ == ranges::end(parent_->base_))
{
trailing_empty_ = true;
next_ = {cur_, cur_};
}
else
next_ = parent_->find_next(cur_);
}
else
trailing_empty_ = false;

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

Non-member functions¶

operator== compares the underlying iterators
(C++20) (function)

operator==(std::ranges::split_view::iterator, std::ranges::split_view::iterator)

friend constexpr bool operator==( const /*iterator*/& x, const (since C++20)
/*iterator*/& y );

Equivalent to return x.cur_ == y.cur_ and x.trailing_empty_ == y.trailing_empty_;.

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::split_view::iterator is
an associated class of the arguments.