std::ranges::lazy_split_view<V, Pattern>::inner_iterator

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

(начиная с C++20)
(только для пояснения*)

Тип возвращаемого значения lazy_split_view::outer_iterator::value_type::begin().

Const соответствует аргументу шаблона outer_iterator.

Типы-члены

Член	Определение
`Base`	`maybe-const` <Const,V> (тип-член, предназначенный только для пояснения*)
`iterator_concept`	`outer_iterator`<Const>::iterator_concept, то есть `std::forward_iterator_tag`, если `Base` моделирует `forward_range`. `std::input_iterator_tag` в противном случае.
`iterator_category` (условно присутствует)	Присутствует только если `Base` моделирует `forward_range`. `std::forward_iterator_tag`, если std::iterator_traits<ranges::iterator_t<Base>>::iterator_category моделирует std::derived_from<std::forward_iterator_tag>. std::iterator_traits<ranges::iterator_t<Base>>::iterator_category в противном случае.
`value_type`	ranges::range_value_t<Base>
`difference_type`	ranges::range_difference_t<Base>

Члены-данные

Член	Описание
`outer_iterator`<Const> `i_` (закрытый)	итератор в базовое `view` родительского объекта `lazy_split_view` (объект-член, предназначенный только для пояснения*)
bool `incremented_` (закрытый)	флаг, указывающий, вызывался ли для этого объекта operator++ хотя бы один раз (объект-член, предназначенный только для пояснения*)

Функции-члены

(конструктор) (C++20)	создаёт итератор (открытая функция-член)
base (C++20)	возвращает базовый итератор (открытая функция-член)
operator* (C++20)	возвращает текущий элемент (открытая функция-член)
operator++operator++(int) (C++20)	перемещает итератор вперёд (открытая функция-член)

Функции-члены

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

/inner_iterator/() = default;	(1)	(начиная с C++20)
constexpr explicit /inner_iterator/( /outer_iterator/<Const> i );	(2)	(начиная с C++20)

1) Инициализирует член-данные i_ значением по умолчанию с помощью его инициализатора члена по умолчанию (= /*outer_iterator*/<Const>()).

2) Инициализирует i_ значением std::move(i).

Член-данные incremented_ инициализируется значением по умолчанию с помощью своего инициализатора члена по умолчанию: false.

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

constexpr const ranges::iterator_t<Base>& base() const & noexcept;	(1)	(начиная с C++20)
constexpr ranges::iterator_t<Base> base() && requires ranges::forward_range<V>;	(2)	(начиная с C++20)

Возвращает копию базового итератора.

1) Создаёт результат копированием базового итератора. Эквивалентно return i_./*cur*/();.

2) Создаёт результат перемещением базового итератора. Эквивалентно return std::move(i_./*cur*/());.

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

constexpr decltype(auto) operator*() const;

(начиная с C++20)

Возвращает элемент, на который указывает базовый итератор.

Эквивалентно return *i_./*cur*/();.

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

constexpr /inner_iterator/& operator++();	(1)	(начиная с C++20)
constexpr decltype(auto) operator++(int);	(2)	(начиная с C++20)

1) Тело функции эквивалентно:

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

2) Эквивалентно:

if constexpr (ranges::forward_range<Base>)
{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
    ++*this; // no return statement

Функции, не являющиеся членами

operator== (C++20)	сравнивает итераторы или итератор и `std::default_sentinel` (функция)
iter_move (C++20)	приводит результат разыменования базового итератора к соответствующему типу rvalue-ссылки (функция)
iter_swap (C++20)	меняет местами объекты, на которые указывают два базовых итератора (функция)

operator==(std::ranges::split_view::inner_iterator)

friend constexpr bool operator==( const /*inner_iterator*/& x,
                                  const /*inner_iterator*/& y )
      requires forward_range<Base>;

(1)

(начиная с C++20)

friend constexpr bool operator==( const /*inner_iterator*/& x,
                                  std::default_sentinel_t );

(2)

(начиная с C++20)

1) Эквивалентно return x.i_./*cur*/() == y.i_./*cur*/();.

2) Тело функции эквивалентно

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;
}

Оператор != синтезируется из operator==.

Эти функции не видны при обычном неквалифицированном поиске или квалифицированном поиске и могут быть найдены только с помощью поиска, зависящего от аргументов, если std::ranges::split_view::inner_iterator является ассоциированным классом аргументов.

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*/())));

(начиная с C++20)

Эквивалентно return ranges::iter_move(i.i_./*cur*/());.

Эта функция не видна при обычном неквалифицированном поиске или квалифицированном поиске и может быть найдена только с помощью поиска, зависящего от аргументов, если std::ranges::split_view::inner_iterator является ассоциированным классом аргументов.

iter_swap(std::ranges::split_view::inner_iterator)

friend constexpr void iter_swap( const /*inner_iterator*/& x,
                                 const /*inner_iterator*/& y )
    noexcept(noexcept(ranges::iter_swap(x.i_.current, y.i_.current)))
    requires std::indirectly_swappable<ranges::iterator_t<Base>>;

(начиная с C++20)

Эквивалентно ranges::iter_swap(x.i_./*cur*/(), y.i_./*cur*/()).

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

Отчёт об ошибке	Применяется к	Опубликованное поведение	Правильное поведение
LWG 3591	C++20	перегрузка `&&` функции `base` могла сделать недействительными внешние итераторы	добавлены ограничения
LWG 3593	C++20	перегрузка `const&` функции `base` возвращала ссылку, но могла не быть noexcept	добавлен спецификатор noexcept

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/ranges/lazy_split_view/inner_iterator