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

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

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

Тип возвращаемого значения для lazy_split_view::begin, и для lazy_split_view::end в случае, если базовый вид является common_range и forward_range.

Если V или Pattern не является простым видом (например, если ranges::iterator_t<const V> недействителен или отличается от ranges::iterator_t<V>), Const является true для итераторов, возвращаемых из константных перегрузок, и false в противном случае. Если V является простым видом, Const является true тогда и только тогда, когда V является forward_range.

Типы членов

Тип члена	Определение
`Parent`	const ranges::lazy_split_view если `Const` является `true`, в противном случае ranges::lazy_split_view (только для примера*)
`Base`	const V если `Const` является `true`, в противном случае `V` (только для примера*)
`iterator_concept` (C++20)	`std::forward_iterator_tag` если `Base` соответствует `forward_range`, в противном случае `std::input_iterator_tag`
`iterator_category` (C++20)	`std::input_iterator_tag` если `Base` соответствует `forward_range`. Отсутствует в противном случае.
`value_type` (C++20)	ranges::lazy_iterator_view<V, Pattern> ::/* outer_iterator */<Const>::value_type
`difference_type` (C++20)	ranges::range_difference_t<Base>.

Члены данных

Имя члена	Определение
`parent_` (private)	Указатель типа `Parent` на родительский объект `lazy_split_view` (только для примера)
`current_` (private)	Итератор типа ranges::iterator_t<Base> в базовый `view`; присутствует только если `V` соответствует `forward_range` (только для примера*)
`trailing_empty_` (private)	Логический флаг, указывающий, была ли достигнута пустая конечная подпоследовательность (если таковая имеется) (только для примера*)

Члены-функции

(конструктор) (C++20)	создает итератор (общедоступная функция-член)
operator* (C++20)	возвращает текущую подпоследовательность (общедоступная функция-член)
operator++operator++(int) (C++20)	перемещает итератор (общедоступная функция-член)
cur (C++20)	возвращает в зависимости от условий ссылку на `current_` (если она есть) или на `parent_->current_` (только для примера)

Члены-функции

std::ranges::lazy_split_view::outer_iterator ::outer_iterator

/* outer_iterator */() = default;	(1)	(с C++20)
constexpr explicit /* outer_iterator */( Parent& parent ) requires (!ranges::forward_range<Base>);	(2)	(с C++20)
constexpr /* outer_iterator */( Parent& parent, ranges::iterator_t<Base> current ) requires ranges::forward_range<Base>;	(3)	(с C++20)
constexpr /* outer_iterator /( / outer_iterator */<!Const> i ) requires Const && std::convertible_to<ranges::iterator_t<V>, ranges::iterator_t<Base>>;	(4)	(с C++20)

1) Значение инициализирует нестатические члены данных с их значениями по умолчанию, то есть:

parent_ = nullptr;,
current_ = iterator_t<Base>(); (присутствует только если V соответствует forward_range),

2) Инициализирует parent_ значением std::addressof(parent).

3) Инициализирует parent_ значением std::addressof(parent) и current_ значением std::move(current).

4) Инициализирует parent_ значением i.parent_, current_ значением std::move(i.current_), и trailing_empty_ значением t.trailing_empty_.

trailing_empty_ инициализируется своим значением по умолчанию в false.

std::ranges::lazy_split_view::outer_iterator ::operator*

constexpr value_type operator*() const;

(с C++20)

Эквивалентно return value_type{*this};.

std::ranges::lazy_split_view::outer_iterator ::operator++

constexpr /* outer_iterator */& operator++();	(1)	(с C++20)
constexpr decltype(auto) operator++(int);	(2)	(с C++20)

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

const auto end = ranges::end(parent_->base_);
if (/* cur */() == end)
{
    trailing_empty_ = false;
    return *this;
}
const auto [pbegin, pend] = ranges::subrange{parent_->pattern_};
if (pbegin == pend)
    ++/* cur */();
else if constexpr (/* tiny_range */<Pattern>)
{
    /* cur */() = ranges::find(std::move(/* cur */()), end, *pbegin);
    if (/* cur */() != end)
    {
        ++/* cur */();
        if (/* cur */() == end)
            trailing_empty_ = true;
    }
}
else
{
    do
    {
        auto [b, p] = ranges::mismatch(/* cur */(), end, pbegin, pend);
        if (p == pend)
        {
            /* cur */() = b;
            if (/* cur */() == end)
                trailing_empty_ = true;
            break; // The pattern matched; skip it
        }
    } while (++/* cur */() != end);
}
return *this;

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

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

END_OF_DOCUMENT_MARKER

std::ranges::lazy_split_view::outer_iterator ::cur ()

constexpr auto& /* cur */() noexcept;	(1)	(с C++20) (только для примера*)
constexpr auto& /* cur */() const noexcept;	(2)	(с C++20) (только для примера*)

Эта вспомогательная функция вызывается из /* outer_iterator */::operator++(), из внечленённой operator==(const /* outer_iterator */&, std::default_sentinel_t), и из некоторых функций-членов возможной реализации inner_iterator.

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

if constexpr (ranges::forward_range<V>)
    return current_;
else
    return *parent->current_;

Внешние функции

operator==

(C++20)

сравнивает базовые итераторы или базовый итератор и std::default_sentinel
(функция)

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

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

(1)

(с C++20)

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

(2)

(с C++20)

1) Эквивалентно return x.current_ == y.current_ and x.trailing_empty_ == y.trailing_empty_;.

2) Эквивалентно return x./* cur */() == ranges::end(x.parent_->base_) and !x.trailing_empty_;.

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

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

Вложенные классы

value_type

(C++20)

тип значения outer_iterator
(внешний вложенный класс)

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

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

DR	Применено к	Поведение при публикации	Корректное поведение
LWG 3904	C++20	`trailing_empty_` не было инициализировано в перегрузке конструктора (4)	инициализировано

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

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

Типы членов

Члены данных

Члены-функции

Члены-функции

std::ranges::lazy_split_view::outer_iterator ﻿::outer_iterator

std::ranges::lazy_split_view::outer_iterator ﻿::operator*

std::ranges::lazy_split_view::outer_iterator ﻿::operator++

std::ranges::lazy_split_view::outer_iterator ﻿::cur ﻿()

Внешние функции

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

Вложенные классы

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

std::ranges::lazy_split_view::outer_iterator ::outer_iterator

std::ranges::lazy_split_view::outer_iterator ::operator*

std::ranges::lazy_split_view::outer_iterator ::operator++

std::ranges::lazy_split_view::outer_iterator ::cur ()