std::ranges::split_view<V,Pattern>:: iterator

From cppreference.com
C++
Ranges library
Range adaptors
std::ranges::split_view
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
parent_ (private) A pointer of type ranges:: split_view < V, Pattern > * to the parent split_view object.
( exposition-only member object* )
cur_ (private) An iterator of type ranges:: iterator_t < V > into the underlying view that points to the begin of a current subrange.
( exposition-only member object* )
next_ (private) A subrange of type ranges:: subrange < ranges:: iterator_t < V >> to the position of the pattern next to the current subrange.
( exposition-only member object* )
trailing_empty_ (private) A boolean flag that indicates whether an empty trailing subrange (if any) was reached.
( exposition-only member object* )

Member functions

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

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

/*iterator*/ ( ) = default ;
(1) (since C++20)
constexpr /*iterator*/ ( split_view & parent, ranges:: iterator_t < V > current,
ranges:: subrange < ranges:: iterator_t < V >> next ) ;
(2) (since C++20)
1) Value-initializes non-static data members with their default member initializers, that is
2) Initializes non-static data members:

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==
(C++20)
compares the underlying iterators
(function)

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

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

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.

Retrieved from " https://en.cppreference.com/mwiki/index.php?title=cpp/ranges/split_view/iterator&oldid=157808 "