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

struct /*iterator*/;

template< class I >
using /*iota-diff-t*/ = /* see below */;

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

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>>;
    };

1) ranges::iota_view<W, Bound>::iterator は、begin() および end() が ranges::iota_view<W, Bound> に対して返すイテレータの型です。

2) イテレータ型と 整数ライク型の両方に対する差分型を計算します。

• I が整数型でない場合、または整数型でありかつ sizeof(std::iter_difference_t<I>) が sizeof(I) より大きい場合、/*iota-diff-t*/<I> は std::iter_difference_t<I> です。
• そうでない場合、/*iota-diff-t*/<I> は、そのような型が存在すれば、I の幅より大きい幅を持つ符号付き整数型です。
• そうでない場合、I は最も広い整数型のうちの1つであり、/*iota-diff-t*/<I> は の幅以上の幅を持つ、未規定の 符号付き整数ライク型Iです。この場合、/*iota-diff-t*/<I> が weakly_incrementable をモデル化するかどうかは未規定です。

3) 型が インクリメント可能であり、前置および後置 operator-- がその型に対して共通の意味を持つことを指定します。

4) 型が decrementable と totally_ordered の両方であり、かつその型およびその異なる型の間での operator+=、operator-=、operator+、および operator- が共通の意味を持つことを指定します。

3) 型 I は decrementable をモデル化するのは、 I が decrementable を満たし、それが包含するすべてのコンセプトがモデル化されており、かつ型 I の等しいオブジェクト a と b が与えられたとき、以下の条件が満たされる場合に限る：

• a と b が前置および後置 operator -- の定義域内にある場合（つまりデクリメント可能である場合）、以下がすべて true である：
  • std:: addressof ( -- a ) == std:: addressof ( a ) ,
  • bool ( a -- == b ) ,
  • bool ( ( ( void ) a -- , a ) == -- b ) ,
  • bool ( ++ ( -- a ) == b ) .
• 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 です。

#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);
}

#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);
}

#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);
}

#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(5).begin()};
    assert(*it == 5);
    assert(*(it += 3) == 8);
}

#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it -= -3) == 9);
}

#include <cassert>
#include <ranges>
int main()
{
    auto it{std::views::iota(6).begin()};
    assert(*it == 6);
    assert(*(it + 3) == 9);
}