Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::lazy_split_view
template < bool Const >
struct /*outer_iterator*/ ;
(C++20 起)
( 仅用于说明* )

lazy_split_view::begin 的返回类型，以及当底层视图为 common_range 且满足 forward_range 时 lazy_split_view::end 的返回类型。

如果 V 或 Pattern 不是 简单视图 （例如当 ranges:: iterator_t < const V > 无效或不同于 ranges:: iterator_t < V > ），则从常量重载返回的迭代器对应的 Const 为 true ，否则为 false 。如果 V 是简单视图，则当且仅当 V 为 forward_range 时 Const 为 true 。

目录

成员类型

成员 定义
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)
构造迭代器
(公开成员函数)
operator*
返回当前子范围
(公开成员函数)
operator++ operator++ (int)
推进迭代器
(公开成员函数)
cur
有条件地返回对 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) 使用 std:: addressof ( parent ) 初始化 parent_ 。
3) 使用 std:: addressof ( parent ) 初始化 parent_ ，并使用 std :: move ( current ) 初始化 current_ 。
4) 使用 i. parent_ 初始化 parent_ ，使用 std :: move ( i. current_ ) 初始化 current_ ，并使用 t. trailing_empty_ 初始化 trailing_empty_ 。

trailing_empty_ 使用其默认成员初始化器初始化为 false 。

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

constexpr value_type operator * ( ) const ;
(since C++20)

等价于 return value_type { * this } ; 。

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

constexpr /*outer_iterator*/ & operator ++ ( ) ;
(1) (since C++20)
constexpr decltype ( auto ) operator ++ ( int ) ;
(2) (since 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; // 模式匹配成功；跳过该模式
        }
    } while (++/*cur*/() != end);
}
return *this;
2) 等价于 
if constexpr (ranges::forward_range<Base>)
{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
{
    ++*this; // 无返回语句
}

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

constexpr auto & /*cur*/ ( ) noexcept ;
(1) (since C++20)
( exposition only* )
constexpr auto & /*cur*/ ( ) const noexcept ;
(2) (since C++20)
( exposition only* )

此便捷成员函数被 /*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 是实参的关联类时，才能通过 实参依赖查找 找到。

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

缺陷报告 应用于 发布时的行为 正确行为
LWG 3904 C++20 构造函数 ( 4 ) 中未初始化 trailing_empty_ 已初始化