Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::lazy_split_view
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
iterator_category
(条件性存在)

仅当 Base 满足 forward_range 时存在。

value_type ranges:: range_value_t < Base >
difference_type ranges:: range_difference_t < Base >

数据成员

成员 描述
outer_iterator < Const > i_ (私有) 指向父对象 lazy_split_view 底层 view 的迭代器
( 仅用于说明的成员对象* )
bool incremented_ (私有) 指示此对象的 operator ++ 是否至少被调用过一次的标志
( 仅用于说明的成员对象* )

成员函数

(constructor)
(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) (since C++20)
constexpr explicit /*inner_iterator*/ ( /*outer_iterator*/ < Const > i ) ;
(2) (since C++20)
1) 通过其默认成员初始化器（= /*outer_iterator*/ < Const > ( ) ）对数据成员 i_ 进行值初始化。
2) 使用 std :: move ( i ) 初始化 i_ 。

数据成员 incremented_ 通过其默认成员初始化器初始化为 false 。

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

constexpr const ranges:: iterator_t < Base > & base ( ) const & noexcept ;
(1) (since C++20)
constexpr ranges:: iterator_t < Base > base ( ) &&
requires ranges:: forward_range < V > ;
(2) (since 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 ;
(since C++20)

返回底层迭代器所指向的元素。

等价于 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) 函数体等价于
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 ; // 无返回语句

非成员函数

operator==
(C++20)
比较迭代器或迭代器与 std::default_sentinel
(函数)
iter_move
(C++20)
将底层迭代器解引用结果转换为其关联的右值引用类型
(函数)
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) (since C++20)
friend constexpr bool operator == ( const /*inner_iterator*/ & x,
std:: default_sentinel_t ) ;
(2) (since 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 >> ;
(since C++20)

等价于 ranges:: iter_swap ( x. i_ . /*cur*/ ( ) , y. i_ . /*cur*/ ( ) ) 。

此函数对普通的 非限定查找 或 限定查找 不可见，仅当 std::ranges::split_view:: inner_iterator 作为参数的关联类时，才能通过 实参依赖查找 找到。

缺陷报告

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

缺陷报告 应用于 发布时的行为 正确行为
LWG 3591 C++20 base 的 && 重载可能使外部迭代器失效 添加约束条件
LWG 3593 C++20 base 的 const & 重载返回引用但可能不保证 noexcept 设为 noexcept