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 および lazy_split_view::end の戻り値の型（基となるビューが common_range かつ forward_range の場合）。

V または Pattern のいずれかが simple view でない場合（例： ranges:: iterator_t < const V > が無効であるか、 ranges:: iterator_t < V > と異なる場合）、 Const はconstオーバーロードから返されるイテレータに対して true となり、それ以外の場合は false となります。 V がsimple viewである場合、 Const は V が forward_range である場合に限り 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)
イテレータを構築する
(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; // パターンが一致したのでスキップ
        }
    } while (++/*cur*/() != end);
}
return *this;
2) 以下と等価 
if constexpr (ranges::forward_range<Base>)
{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
{
    ++*this; // return文なし
}

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 ）で初期化されていなかった 初期化される