Namespaces
Variants

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

    ja.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::endcommon_range かつ forward_range である場合の の戻り値の型。

    V または Pattern が simple view でない場合（例えば ranges::iterator_t<const V> が無効であるか ranges::iterator_t<V> と異なる場合）、Const は const オーバーロードから返されるイテレータに対しては true であり、それ以外の場合は false です。V が simple view である場合、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_ への参照を返す
    ( 説明専用メンバ関数* )

    メンバー関数

    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) (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++規格に対して遡及的に適用されました。

    DR 適用対象 公開時の動作 正しい動作
    LWG 3904 C++20 trailing_empty_ がコンストラクタ（ 4 ）で初期化されていなかった 初期化される