命名空间
变体
操作

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

来自 cppreference.com
 
C++
 
范围库
范围适配器
 
std::ranges::lazy_split_view
 
template< bool Const >
struct /*inner_iterator*/;
 (自 C++20 起)
(仅供说明*)

lazy_split_view::outer_iterator::value_type::begin() 的返回类型。

Const 与 outer_iterator 的模板参数匹配。

内容

[编辑] 成员类型

成员 定义
基础 maybe-const <Const, V>
(仅供说明成员类型*)
iterator_concept (C++20)
iterator_category (C++20)
(条件存在)

仅在 Base 模仿 forward_range 时存在。

value_type (C++20) ranges::range_value_t<Base>
difference_type (C++20) ranges::range_difference_t<Base>

[编辑] 数据成员

成员 定义
/*outer_iterator*/<Const> i_ (私有) 父对象 lazy_split_view 的基础 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) 使用其默认成员初始化程序 (= /*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) (自 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; // 无返回值语句

[编辑] 非成员函数

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

此函数对普通的 非限定 或 限定查找不可见，只有当 std::ranges::split_view::inner_iterator 是参数的关联类时，才能通过 参数依赖查找找到它们。

[编辑] 缺陷报告

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

DR 应用于 发布的行为 正确行为
LWG 3591 C++20 base 的 && 重载可能会使外部迭代器失效 添加了约束
LWG 3593 C++20 base 的 const& 重载返回引用，但可能不是 noexcept 改为 noexcept
检索自 "https://cppreference.cn/mwiki/index.php?title=cpp/ranges/lazy_split_view/inner_iterator&oldid=175916"