Namespaces
Variants

std::ranges:: iota_view<W, Bound>:: iterator

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::iota_view
Member functions
Deduction guides
Nested classes
Iterator
Helper concepts
Member types
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
（注：このHTML要素には翻訳対象のテキストコンテンツが含まれていないため、元の構造をそのまま保持しています）
struct /*iterator*/ ;
(1) ( 説明専用* )
ヘルパーエイリアステンプレート
template < class I >
using /*iota-diff-t*/ = /* 下記参照 */ ;
(2) ( 説明専用* )
ヘルパーコンセプト
template < class I >

concept /*decrementable*/ =
std:: incrementable < I > && requires ( I i ) {
{ -- i } - > std:: same_as < I & > ;
{ i -- } - > std:: same_as < I > ;

} ;
(3) ( 説明専用* )
template < class I >

concept /*advanceable*/ =
/*decrementable*/ < I > && std:: totally_ordered < I > &&
requires ( I i, const I j, const /*iota-diff-t*/ < I > n ) {
{ i + = n } - > std:: same_as < I & > ;
{ i - = n } - > std:: same_as < I & > ;
I ( j + n ) ;
I ( n + j ) ;
I ( j - n ) ;
{ j - j } - > std:: convertible_to < /*iota-diff-t*/ < I >> ;

} ;
(4) ( 説明専用* )
1) ranges:: iota_view < W, Bound > :: iterator は、 ranges:: iota_view < W, Bound > の begin() および end() によって返されるイテレータの型です。
2) 両方のイテレータ型と integer-like types のdifference typeを計算する。
  • I が整数型でない場合、または整数型であり sizeof ( std:: iter_difference_t < I > ) が sizeof ( I ) より大きい場合、 /*iota-diff-t*/ < I > は std:: iter_difference_t < I > である。
  • それ以外の場合、 /*iota-diff-t*/ < I > は I の幅より大きい幅を持つ符号付き整数型である（そのような型が存在する場合）。
  • それ以外の場合、 I は最も幅の広い整数型の一つであり、 /*iota-diff-t*/ < I > は I の幅以上を持つ未指定の signed-integer-like type である。この場合、 /*iota-diff-t*/ < I > が weakly_incrementable をモデル化するかどうかは未指定である。
3) 型が incrementable であることを指定し、その型に対する前置および後置 operator -- が共通の意味を持つことを示す。
4) 型が decrementable かつ totally_ordered であり、さらに operator + = 、 operator - = 、 operator + 、および operator - が型とその異なる型の間で共通の意味を持つことを指定します。

/*iterator*/ モデル

しかし、これは LegacyInputIterator を満たすのは W が incrementable をモデル化する場合のみであり、そうでない場合は LegacyInputIterator を満たしません。

目次

セマンティック要件

3) 型 I は decrementable をモデル化するのは、 I が decrementable を満たし、それが包含するすべてのコンセプトがモデル化されており、かつ型 I の等しいオブジェクト a と b が与えられたとき、以下の条件が満たされる場合に限る：
  • a と b が前置および後置 operator -- の定義域内にある場合（つまりデクリメント可能である場合）、以下がすべて true である：
  • a と b が前置および後置 operator ++ の定義域内にある場合（つまりインクリメント可能である場合）、 bool ( -- ( ++ a ) == b ) は true である。
4) Let D denote /*iota-diff-t*/ < I > . Type I models advanceable only if I satisfies advanceable and all concepts it subsumes are modeled, and given
  • 型 I のオブジェクト a と b 、および
  • 型 D の値 n 、

以下のすべての条件が満たされる場合、 b は a から n 回の ++ a 適用後に到達可能である：

  • ( a + = n ) は b と等しい。
  • std:: addressof ( a + = n ) は std:: addressof ( a ) と等しい。
  • I ( a + n ) は ( a + = n ) と等しい。
  • 型 D の任意の正の値 x と y について、 I ( a + D ( x + y ) ) が適切に定義されている場合、 I ( a + D ( x + y ) ) は I ( I ( a + x ) + y ) と等しい。
  • I ( a + D ( 0 ) ) は a と等しい。
  • I ( a + D ( n - 1 ) ) が well-defined である場合、 I ( a + n ) は [ ] ( I c ) { return ++ c ; } ( I ( a + D ( n - 1 ) ) ) と等しい。
  • ( b + = - n ) は a と等しい。
  • ( b - = n ) は a と等しい。
  • std:: addressof ( b - = n ) は std:: addressof ( b ) と等しい。
  • I ( b - n ) は ( b - = n ) に等しい。
  • D ( b - a ) は n に等しい。
  • D ( a - b ) は D ( - n ) に等しい。
  • bool ( a <= b ) は true です。

ネスト型

型 定義
iterator_concept イテレータタグ 、下記参照
iterator_category
( W が incrementable をモデル化し、
/*iota-diff-t*/ < W > が整数型である場合にのみ存在) 		std::input_iterator_tag
value_type W
difference_type /*iota-diff-t*/ < W >

イテレータコンセプトの決定

iterator_concept は以下のように定義されます:

データメンバ

メンバー 定義
W value_ 現在の値
( 説明専用メンバーオブジェクト* )

メンバー関数

std::ranges::iota_view:: iterator :: iterator

/*iterator*/ ( ) requires std:: default_initializable < W > = default ;
(1) (since C++20)
constexpr explicit /*iterator*/ ( W value ) ;
(2) (since C++20)
1) value_ を値初期化します。
2) value_ を value で初期化します。

std::ranges::iota_view:: iterator :: operator*

constexpr W operator * ( ) const
noexcept ( std:: is_nothrow_copy_constructible_v < W > ) ;
(C++20以降)

value_ を返します。

例

このコードを実行 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6, 9).begin()};
    const int& r = *it; // 一時オブジェクトにバインド
    assert(*it == 6 and r == 6);
    ++it;
    assert(*it == 7 and r == 6);
}

std::ranges::iota_view:: iterator :: operator++

constexpr /*iterator*/ & operator ++ ( ) ;
(1) (C++20以降)
constexpr void operator ++ ( int ) ;
(2) (C++20以降)
constexpr /*iterator*/ operator ++ ( int ) requires std:: incrementable < W > ;
(3) (C++20以降)
1) ++ value_ ; return *this; と等価。
2) ++ value_ ; と等価。
3) auto tmp = *this; ++ value_ ; return tmp; と等価。

例

このコードを実行 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*++it == 9);
    assert(*it++ == 9);
    assert(*it == 10);
}

std::ranges::iota_view:: iterator :: operator--

constexpr /*iterator*/ & operator -- ( ) requires /*decrementable*/ < W > ;
(1) (C++20以降)
constexpr /*iterator*/ operator -- ( int ) requires /*decrementable*/ < W > ;
(2) (C++20以降)
1) 以下と同等: -- value_  ; return * this ; .
2) 以下と同等: auto tmp = * this ; -- value_  ; return tmp ; .

例

このコードを実行 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(8).begin()};
    assert(*it == 8);
    assert(*--it == 7);
    assert(*it-- == 7);
    assert(*it == 6);
}

std::ranges::iota_view:: iterator :: operator+=

constexpr /*iterator*/ & operator + = ( difference_type n )
requires /*advanceable*/ < W > ;
(C++20以降)

value_ を更新し、 * this を返します：

  • W が 符号なし整数様型 の場合：
    • n が非負の場合は、 value_ + = static_cast < W > ( n ) を実行します。
    • それ以外の場合は、 value_ - = static_cast < W > ( - n ) を実行します。
  • それ以外の場合は、 value_ + = n を実行します。

例

このコードを実行 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(5).begin()};
    assert(*it == 5);
    assert(*(it += 3) == 8);
}

std::ranges::iota_view:: iterator :: operator-=

constexpr /*iterator*/ & operator - = ( difference_type n )
requires /*advanceable*/ < W > ;
(C++20以降)

value_ を更新し、 * this を返します：

  • W が 符号なし整数様型 の場合：
    • n が非負の場合、 value_ - = static_cast < W > ( n ) を実行します。
    • それ以外の場合、 value_ + = static_cast < W > ( - n ) を実行します。
  • それ以外の場合、 value_ - = n を実行します。

例

このコードを実行 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it -= -3) == 9);
}

std::ranges::iota_view:: iterator :: operator[]

constexpr W operator [ ] ( difference_type n ) const
requires /*advanceable*/ < W > ;
(C++20以降)

value_ + n を返します。

例

このコードを実行 
#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it + 3) == 9);
}

非メンバー関数

operator==, <, >, <=, >=, <=> (std::ranges::iota_view:: iterator )

friend constexpr bool operator ==

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: equality_comparable < W > ;
(1) (C++20以降)
friend constexpr bool operator <

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > ;
(2) (C++20以降)
friend constexpr bool operator >

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > ;
(3) (C++20以降)
friend constexpr bool operator <=

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > ;
(4) (C++20以降)
friend constexpr bool operator >=

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > ;
(5) (C++20以降)
friend constexpr bool operator <=>

( const /*iterator*/ & x, const /*iterator*/ & y )

requires std:: totally_ordered < W > && std:: three_way_comparable < W > ;
(6) (C++20以降)
1) value_ が x. value_ == y. value_ と等しい場合に value_ を返す。
2) 次を返す x. value_ < y. value_ .
3) 戻り値 y < x .
4) 戻り値 ! ( y < x ) .
5) 次を返す ! ( x < y ) 。
6) 次を返す x. value_ <=> y. value_ 。

!= 演算子は synthesized され、 operator== から生成されます。

これらの関数は通常の unqualified lookup または qualified lookup では可視化されず、 argument-dependent lookup によってのみ発見可能です（ iterator が引数の関連クラスである場合に限ります）。

operator+ (std::ranges::iota_view:: iterator )

friend constexpr /*iterator*/ operator +

( /*iterator*/ i, difference_type n )

requires /*advanceable*/ < W > ;
(1) (C++20以降)
friend constexpr /*iterator*/ operator +

( difference_type n, /*iterator*/ i )

requires /*advanceable*/ < W > ;
(2) (C++20以降)

i += n; return i; と等価。

これらの関数は通常の 非修飾名探索 または 修飾名探索 では可視化されず、 iterator が引数の関連クラスである場合にのみ 実引数依存の名前探索 によって発見される。

operator- (std::ranges::iota_view:: iterator )

friend constexpr /*iterator*/ operator -

( /*iterator*/ i, difference_type n )

requires /*advanceable*/ < W > ;
(1) (C++20以降)
friend constexpr difference_type operator -

( const /*iterator*/ & x, const /*iterator*/ & y )

requires /*advanceable*/ < W > ;
(2) (C++20以降)
1) i -= n; return i; と等価。
2) D を difference_type とする：
  • W が 整数様型 の場合：
    • W が符号付き整数様の場合、 D(D(x.value_) - D(y.value_)) を返す。
    • それ以外の場合、 y.value_ > x.value_ ? D(-D(y.value_ - x.value_)) : D(x.value_ - y.value_) を返す。
  • それ以外の場合、 x.value_ - y.value_ を返す。

これらの関数は通常の 非修飾名探索 または 修飾名探索 では可視化されず、 iterator が引数の関連クラスである場合にのみ 実引数依存の名前探索 によって発見される。

不具合報告

以下の動作変更の欠陥報告書は、以前に公開されたC++規格に対して遡及的に適用されました。

DR 適用対象 公開時の動作 正しい動作
P2259R1 C++20 メンバー iterator_category は常に定義される W が incrementable を満たす場合のみ定義される
LWG 3580 C++20 operator + および operator - の本体が 暗黙のmove を妨げる 暗黙のmoveに適するように修正