std::ranges::iota_view 和 std::views::iota 是 C++23 Ranges 库中的一部分，用于生成一系列递增的值，类似 Python 的 range() 或传统的 for 循环生成器。

一 原形

Defined in header <numeric>
Call signature
template< std::input_or_output_iterator O, std::sentinel_for<O> S,           std::weakly_incrementable T > requires std::indirectly_writable<O, const T&> constexpr iota_result<O, T>     iota( O first, S last, T value );	(1)	(since C++23)
template< std::weakly_incrementable T, ranges::output_range<const T&> R > constexpr iota_result<ranges::borrowed_iterator_t<R>, T>     iota( R&& r, T value );	(2)	(since C++23)
Helper types
template< class O, class T > using iota_result = ranges::out_value_result<O, T>;	(3)	(since C++23)

Fills the range [first, last) with sequentially increasing values, starting with value and repetitively evaluating ++value.

Equivalent operation:

*(first)     = value;
*(first + 1) = ++value;
*(first + 2) = ++value;
*(first + 3) = ++value;
...

Parameters

first, last	-	the iterator-sentinel pair defining the range of elements to fill with sequentially increasing values starting with value
value	-	initial value to store; the expression ++value must be well-formed

Return value

{last, value + ranges::distance(first, last)}

Complexity

Exactly last - first increments and assignments.

二、用途

std::views::iota(start)
生成从 start 开始的 无限递增序列

std::views::iota(start, stop)
生成从 start 开始，到 不包括 stop 的 有限递增序列

---

✅ 三、示例用法

示例 1：生成有限整数序列

#include <ranges>
#include <iostream>

int main() 
{
    for (int i : std::views::iota(0, 5)) 
    {
        std::cout << i << ' ';
    }
    std::cout << '\n';
}

 输出:

0 1 2 3 4

示例 2：无限序列 + 截断

#include <ranges>
#include <iostream>

int main() 
{
    auto infinite = std::views::iota(10);  // 无限递增从10开始

    for (int i : infinite | std::views::take(5)) 
    {
        std::cout << i << ' ';
    }
    std::cout << '\n';
}

输出：

10 11 12 13 14

示例 3：与自定义类型（如枚举或结构体）一起使用

你可以使用 std::views::iota 生成 enum, char, 或 std::chrono::time_point 等递增类型：

#include <ranges>
#include <iostream>

struct Test 
{
    int value;

    static constexpr int min = 0;
    static constexpr int max = 3;

    // 构造函数
    constexpr Test(int v = min) : value(v) {}

    // operator++ (前置递增)
    Test& operator++() {
        if (value < max) {
            ++value;
        }
        return *this;
    }

    // 比较运算符
    friend constexpr bool operator==(Test lhs, Test rhs) {
        return lhs.value == rhs.value;
    }

    friend constexpr bool operator!=(Test lhs, Test rhs) {
        return !(lhs == rhs);
    }

    friend constexpr bool operator<(Test lhs, Test rhs) {
        return lhs.value < rhs.value;
    }
};

int main() 
{
    for (Test c : std::views::iota(Test::min, Test::max)) 
    {
        std::cout << c.value << ' ';
    }
}

要求类型支持 operator++（即满足 std::weakly_incrementable）。

四、特性总结

特性	描述
惰性生成	元素按需生成，不占用内存
无限或有限序列	可以无限增长，也可以指定边界
类型支持	任何可自增类型，如整数、枚举、时间点
常与 views::take 配合	限制无限序列长度
范围特性	支持 forward range，支持迭代算法

五、组合使用案例

生成带序号的字符串：

#include <iostream>
#include <ranges>
#include <string>

int main() 
{
    auto greetings = std::views::iota(1)
                   | std::views::take(3)
                   | std::views::transform([](int i) {
                         return "Hello " + std::to_string(i);
                     });

    for (auto&& s : greetings) 
    {
        std::cout << s << '\n';
    }
}

 输出：

Hello 1
Hello 2
Hello 3
 

常见误区

错误用法	正确方式
iota(0, n + 1.5) (混类型)	确保起始和终止类型一致
iota(begin, end) 忘记终止值	无限序列需要 take 来终止
用于不支持 ++ 的类型	类型需支持自增（++）

---

🧾 总结表

形式	描述
std::views::iota(5)	无限递增从 5 开始
std::views::iota(5, 10)	有限递增：5 到 9
iota_view<char>('a', 'z'+1)	生成 a~z 字符
views::iota(tp1, tp2)	生成时间点 range（C++20）