A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://en.cppreference.com/w/cpp/algorithm/ranges/../../ranges/lazy_split_view/inner_iterator.html below:

std::ranges::lazy_split_view<V, Pattern>::inner_iterator - cppreference.com

template< bool Const >
struct /*inner_iterator*/;

(since C++20)
(exposition only*)

The return type of lazy_split_view::outer_iterator::value_type::begin().

Const matches the template argument of outer_iterator.

[edit] Member types [edit] Data members Member Description outer_iterator<Const> i_ (private) an iterator into the underlying view of the parent object lazy_split_view
(exposition-only member object*) bool incremented_ (private) a flag that indicates whether the operator++ was invoked on this object at least once
(exposition-only member object*) [edit] Member functions constructs an iterator
(public member function) returns the underlying iterator
(public member function) returns the current element
(public member function)

operator++operator++(int)

(C++20)

advances the iterator
(public member function) [edit] Member functions std::ranges::lazy_split_view::inner_iterator::inner_iterator

/*inner_iterator*/() = default;

(1) (since C++20)

constexpr explicit /*inner_iterator*/( /*outer_iterator*/<Const> i );

(2) (since C++20) 1)

Value initializes data member

i_

via its default member initializer (=

/*outer_iterator*/<Const>()

).

2)

Initializes

i_

with

std::move(i)

.

The data member incremented_ is initialized with its default member initializer to false.

std::ranges::lazy_split_view::inner_iterator::base

Returns a copy of the underlying iterator.

1) Copy constructs the result from the underlying iterator. Equivalent to return i_./*cur*/();.

2) Move constructs the result from the underlying iterator. Equivalent to return std::move(i_./*cur*/());.

std::ranges::lazy_split_view::inner_iterator::operator*

constexpr decltype(auto) operator*() const;

(since C++20)

Returns the element the underlying iterator points to.

Equivalent to return *i_./*cur*/();.

std::ranges::lazy_split_view::inner_iterator::operator++

constexpr /*inner_iterator*/& operator++();

(1) (since C++20)

constexpr decltype(auto) operator++(int);

(2) (since C++20) 1)

The function body is equivalent to


incremented_ = true;

if constexpr (!ranges::forward_range<Base>)
{
    if constexpr (Pattern::size() == 0)
        return *this;
}
++i_./*cur*/();

return *this; 2)

Equivalent to


if constexpr (ranges::forward_range<Base>)

{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
    ++*this; // no return statement

 [edit] Non-member functions compares the iterators or the iterator and std::default_sentinel
(function) casts the result of dereferencing the underlying iterator to its associated rvalue reference type
(function) swaps the objects pointed to by two underlying iterators
(function) operator==(std::ranges::split_view::inner_iterator) friend constexpr bool operator==( const /*inner_iterator*/& x,

                                  const /*inner_iterator*/& y )

      requires forward_range<Base>; (1) (since C++20) (2) (since C++20)

1) Equivalent to return x.i_./*cur*/() == y.i_./*cur*/();.

2)

The function body is equivalent to

auto [pcur, pend] = ranges::subrange{x.i_.parent_->pattern_};
auto end = ranges::end(x.i_.parent_->base_);
if constexpr (/*tiny_range*/<Pattern>)
{
    const auto& cur = x.i_./*cur*/();
    if (cur == end)
        return true;
    if (pcur == pend)
        return x.incremented_;
    return *cur == *pcur;
}
else
{
    auto cur = x.i_./*cur*/();
    if (cur == end)
        return true;
    if (pcur == pend)
        return x.incremented_;
    do
    {
        if (*cur != *pcur)
            return false;
        if (++pcur == pend)
            return true;
    }
    while (++cur != end);
    return false;
}

The != operator is synthesized from operator==.

These functions are not visible to ordinary unqualified or qualified lookup, and can only be found by argument-dependent lookup when std::ranges::split_view::inner_iterator is an associated class of the arguments.

iter_move(std::ranges::split_view::inner_iterator) friend constexpr decltype(auto) iter_move( const /*inner_iterator*/& i )
    noexcept(noexcept(ranges::iter_move(i.i_./*cur*/()))); (since C++20)

Equivalent to return ranges::iter_move(i.i_./*cur*/());.

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::inner_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 LWG 3591 C++20 the && overload of base might invalidate outer iterators constraints added LWG 3593 C++20 the const& overload of base returns a reference but might not be noexcept made noexcept

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4