Namespaces
Variants

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

    С сайта ru.cppreference.net
     
    C++
    Поддержка компиляторов
    Автономные и хостируемые реализации
    Язык
    Стандартная библиотека
    Заголовки стандартной библиотеки
    Именованные требования
    Макросы проверки возможностей (C++20)
    Библиотека поддержки языка
    Библиотека концептов (C++20)
    Библиотека диагностики
    Библиотека управления памятью
    Библиотека метапрограммирования (C++11)
    Библиотека общих утилит
    Библиотека контейнеров
    Библиотека итераторов
    Библиотека диапазонов (C++20)
    Библиотека алгоритмов
    Библиотека строк
    Библиотека обработки текста
    Библиотека численных операций
    Библиотека даты и времени
    Библиотека ввода/вывода
    Библиотека файловой системы (C++17)
    Библиотека поддержки конкурентности (C++11)
    Библиотека управления выполнением (C++26)
    Технические спецификации
    Указатель символов
    Внешние библиотеки
     
    Библиотека диапазонов
    Адаптеры диапазонов
     
    std::ranges::lazy_split_view
     
    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 maybe-const  < Const, ranges:: lazy_split_view >
    ( только для демонстрации* )
    Base maybe-const  < Const, V >
    ( только для демонстрации* )
    iterator_concept
    iterator_category
    (присутствует только если Base моделирует forward_range )     		std::input_iterator_tag
    		тип значения outer_iterator
    (публичный класс-член)
    difference_type ranges:: range_difference_t < Base >

    Члены данных

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

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

    (constructor)
    		создает итератор
    (public member function)
    operator*
    		возвращает текущий поддиапазон
    (public member function)
    operator++ operator++ (int)
    		продвигает итератор
    (public member function)
    cur
    		условно возвращает ссылку на current_ (если присутствует) или на * parent_ - > current_
    ( exposition-only member function* )

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

    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
}

    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) (since C++20)
    friend constexpr bool operator == ( const /*outer_iterator*/ & x,
    std:: default_sentinel_t ) ;
    		(2) (since 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 является ассоциированным классом аргументов.

    Отчёты о дефектах

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

    DR Applied to Behavior as published Correct behavior
    LWG 3904 C++20 trailing_empty_ не инициализировался в конструкторе ( 4 ) инициализируется