名稱空間
變體
操作

std::ranges::iota_view<W, Bound>::迭代器

來自 cppreference.com
< cpp‎ | ranges‎ | iota_view
 
C++
 
範圍庫 (Ranges library)
範圍介面卡 (Range adaptors)
 
std::ranges::iota_view
成員函式
推導指引
巢狀類
迭代器 (Iterator)
輔助概念
成員型別
成員函式
非成員函式
哨兵 (Sentinel)
成員函式
非成員函式
 
struct /*iterator*/;
 (1) (僅作說明*)
輔助別名模板
template< class I >
using /*iota-diff-t*/ = /* 見下文 */;
 (2) (僅作說明*)
輔助概念
template< class I >

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

    };
 (3) (僅作說明*)
template< class I >

概念 /*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) 計算迭代器型別和 整數類型別 的差值型別。
  • 如果 I 不是整數型別，或者它是一個整數型別且 sizeof(std::iter_difference_t<I>) 大於 sizeof(I)，則 /*iota-diff-t*/<I> 是 std::iter_difference_t<I>。
  • 否則，如果存在寬度大於 I 的帶符號整數型別，則 /*iota-diff-t*/<I> 是該型別。
  • 否則，I 是最寬的整數型別之一，且 /*iota-diff-t*/<I> 是一個未指定的 帶符號整數類型別，其寬度不小於 I 的寬度。在這種情況下，/*iota-diff-t*/<I> 是否是 weakly_incrementable 的模型是未指定的。
3) 指定一個型別是 incrementable，並且該型別的前置和後置 operator-- 具有共同的含義。
4) 指定一個型別既是 decrementable 又是 totally_ordered，並且該型別與其差值型別之間的 operator+=、operator-=、operator+ 和 operator- 具有共同的含義。

/*iterator*/ 模型

然而，它僅在 W 模型 incrementable 時才滿足 LegacyInputIterator，否則不滿足 LegacyInputIterator。

目錄

[編輯] 語義要求

3) 型別 I 僅當 I 滿足 decrementable 且其包含的所有概念都得到模型化時才模型 decrementable，並且給定型別 I 的相等物件 a 和 b
  • 如果 a 和 b 都在前置和後置 operator-- 的域中（即它們是可遞減的），則以下所有條件都為 true
  • 如果 a 和 b 都在前置和後置 operator++ 的域中（即它們是可遞增的），則 bool(--(++a) == b) 為 true。
4) 令 D 表示 /*iota-diff-t*/<I>。型別 I 僅當 I 滿足 advanceable 且其包含的所有概念都得到模型化時才模型 advanceable，並且給定
  • 型別 I 的物件 a 和 b，以及
  • 型別 D 的值 n，

使得 n 次應用 ++a 後，b 可從 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)) 是定義良好的，則 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) (C++20 起)
constexpr explicit /*iterator*/( W value );
 (2) (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; // binds with temporary
    assert(*it == 6 and r == 6);
    ++it;
    assert(*it == 7 and r == 6);
}

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

constexpr /*迭代器*/& 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

示例

執行此程式碼
#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

示例

執行此程式碼
#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 起)

返回 W(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) 返回 x.value_ == y.value_。
2) 返回 x.value_ < y.value_。
3) 返回 y < x。
4) 返回 !(y < x)。
5) 返回 !(x < y)。
6) 返回 x.value_ <=> y.value_。

!= 運算子由 operator== 合成。

這些函式在普通的 非限定查詢 或 限定查詢 中不可見，並且僅當 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

這些函式在普通的 非限定查詢 或 限定查詢 中不可見，並且僅當 iterator 是引數的關聯類時才能透過 引數依賴查詢 找到。

[編輯] 缺陷報告

下列更改行為的缺陷報告追溯地應用於以前出版的 C++ 標準。

缺陷報告 應用於 釋出時的行為 正確的行為
P2259R1 C++20 成員 iterator_category 始終有定義 僅當 W 滿足 incrementable 時定義
LWG 3580 C++20 operator+ 和 operator- 的主體排除了隱式移動 已使其適用於隱式移動
取自“https://cppreference.tw/mwiki/index.php?title=cpp/ranges/iota_view/iterator&oldid=176931”