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_ (private) 親オブジェクトの基になる view へのイテレータ lazy_split_view
( 説明専用メンバーオブジェクト* )
bool incremented_ (private) このオブジェクトに対して operator ++ が少なくとも1回呼び出されたかどうかを示すフラグ
( 説明専用メンバーオブジェクト* )

メンバー関数

(constructor)
(C++20)
イテレータを構築する
(public member function)
base
(C++20)
基となるイテレータを返す
(public member function)
operator*
(C++20)
現在の要素を返す
(public member function)
operator++ operator++ (int)
(C++20)
イテレータを進める
(public member function)

メンバー関数

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) データメンバ i_ をそのデフォルトメンバ初期化子 (= /*outer_iterator*/ < Const > ( ) ) で値初期化します。
2) i_ を std :: move ( 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)
2つの基盤となるイテレータが指すオブジェクトを交換する
(関数)

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) 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化