C++ `generator` (C++23)：使用协程实现惰性求值的序列生成器

好的，没问题，直接进入主题！

各位观众老爷，大家好！今天咱们聊聊C++23里新加入的“generator”，这玩意儿可是个好东西，能让你用协程优雅地实现惰性求值的序列生成器。简单来说，就是你想用多少就生成多少，不用一股脑全算出来，省时省力，妈妈再也不用担心我的内存爆炸了！

为啥需要惰性求值？

在说generator之前，先来聊聊为啥我们需要惰性求值。设想一个场景，你需要计算一个巨大的斐波那契数列，比如前100万项。如果直接用循环计算并存储所有结果，那内存可要吃紧了。而且，如果你只需要前10项，后面的999990项就算出来也浪费了。

惰性求值就像“现吃现做”，你想要第n项，它才计算第n项，之前的项算完就可以扔掉了，内存占用大大降低。

generator闪亮登场

C++23的generator就是为了实现这种惰性求值而生的。它基于协程，允许你像写普通函数一样生成序列，但实际上数据是按需生成的。

generator的基本用法

generator定义在<generator>头文件中。最简单的用法如下：

#include <iostream>
#include <generator>

std::generator<int> count_up_to(int max) {
  for (int i = 0; i <= max; ++i) {
    co_yield i;
  }
}

int main() {
  for (int i : count_up_to(5)) {
    std::cout << i << " ";
  }
  std::cout << std::endl; // 输出：0 1 2 3 4 5
  return 0;
}

这段代码定义了一个名为count_up_to的生成器函数，它生成从0到max的整数序列。注意几个关键点：

std::generator<int>：指定生成器产生int类型的序列。
co_yield i：这是协程的关键，它暂停函数的执行，并将i作为序列的下一个元素返回。下次迭代时，函数从co_yield语句之后继续执行。

main函数中，我们用一个范围for循环遍历生成器，每次循环都会请求生成器产生一个新的值。生成器函数执行到co_yield，产生一个值并暂停。下次循环再次请求值，函数从上次暂停的地方继续执行。直到for循环结束，或者生成器函数执行完毕，遍历结束。

co_yield的秘密

co_yield是generator的核心。它有点像return，但又不一样。return会结束函数，而co_yield只是暂停函数，并返回一个值。它有以下几种形式：

co_yield value;：产生一个值，类型必须与generator模板参数一致。
co_yield std::move(value);：产生一个值，移动语义，避免不必要的拷贝。
co_return;：结束生成器函数，不再产生任何值。

一个稍微复杂点的例子：斐波那契数列

#include <iostream>
#include <generator>

std::generator<long long> fibonacci() {
  long long a = 0;
  long long b = 1;
  while (true) {
    co_yield a;
    long long next = a + b;
    a = b;
    b = next;
  }
}

int main() {
  int count = 0;
  for (long long num : fibonacci()) {
    std::cout << num << " ";
    if (++count > 10) break;
  }
  std::cout << std::endl; // 输出：0 1 1 2 3 5 8 13 21 34 55
  return 0;
}

这个例子生成一个无限的斐波那契数列。注意while (true)循环，这意味着如果不加限制，它会一直生成下去。main函数中，我们只取前11项，避免无限循环。

generator的优势

内存效率： 只在需要时生成值，避免存储大量数据。
代码简洁： 用普通函数的形式编写序列生成逻辑，易于理解和维护。
无限序列： 可以轻松生成无限序列，而无需担心内存耗尽。
可组合性： 可以将多个生成器组合起来，构建更复杂的序列。

generator的类型推导

C++23还支持generator的类型推导，你可以使用auto关键字，让编译器自动推导生成器的类型：

#include <iostream>
#include <generator>

auto count_up_to(int max) {
  for (int i = 0; i <= max; ++i) {
    co_yield i;
  }
}

int main() {
  for (int i : count_up_to(5)) {
    std::cout << i << " ";
  }
  std::cout << std::endl; // 输出：0 1 2 3 4 5
  return 0;
}

编译器会自动推导出count_up_to的返回类型为std::generator<int>。

generator的局限性

协程开销： 协程的创建和切换会带来一定的开销，对于简单的序列生成，可能不如直接使用循环效率高。
调试困难： 协程的执行流程比较复杂，调试起来可能比较困难。
异常处理： 需要注意协程中的异常处理，避免程序崩溃。

generator的进阶用法

生成复杂类型： generator可以生成任何类型的序列，包括自定义类型。

#include <iostream>
#include <generator>
#include <string>

struct Person {
  std::string name;
  int age;
};

std::generator<Person> generate_people() {
  co_yield {"Alice", 30};
  co_yield {"Bob", 25};
  co_yield {"Charlie", 40};
}

int main() {
  for (const auto& person : generate_people()) {
    std::cout << person.name << " is " << person.age << " years old." << std::endl;
  }
  // 输出：
  // Alice is 30 years old.
  // Bob is 25 years old.
  // Charlie is 40 years old.
  return 0;
}

组合多个generator： 可以将多个generator组合起来，生成更复杂的序列。

#include <iostream>
#include <generator>

std::generator<int> count_up_to(int max) {
  for (int i = 0; i <= max; ++i) {
    co_yield i;
  }
}

std::generator<int> count_down_from(int min) {
  for (int i = min; i >= 0; --i) {
    co_yield i;
  }
}

std::generator<int> combine_generators(int max, int min) {
  for (int i : count_up_to(max)) {
    co_yield i;
  }
  for (int i : count_down_from(min)) {
    co_yield i;
  }
}

int main() {
  for (int i : combine_generators(3, 2)) {
    std::cout << i << " ";
  }
  std::cout << std::endl; // 输出：0 1 2 3 2 1 0
  return 0;
}

在generator中处理异常： 需要使用try...catch块来捕获并处理异常。

#include <iostream>
#include <generator>
#include <stdexcept>

std::generator<int> generate_with_exception(int max) {
  for (int i = 0; i <= max; ++i) {
    if (i == 3) {
      throw std::runtime_error("Something went wrong!");
    }
    co_yield i;
  }
}

int main() {
  try {
    for (int i : generate_with_exception(5)) {
      std::cout << i << " ";
    }
    std::cout << std::endl;
  } catch (const std::exception& e) {
    std::cerr << "Caught exception: " << e.what() << std::endl;
  }
  // 输出：
  // 0 1 2 Caught exception: Something went wrong!
  return 0;
}

generator与其他技术的比较

技术	优点	缺点	适用场景
循环	简单易懂，效率高（对于简单序列）	无法实现惰性求值，需要一次性生成所有数据，内存占用高。对于无限序列，无法处理。	数据量小，需要一次性计算所有结果的场景。
迭代器	可以实现惰性求值，但需要手动实现迭代器类，代码较为复杂。	代码复杂，学习曲线陡峭。	需要高度定制的迭代行为，或者需要与现有迭代器框架集成。
`generator`	简单易用，使用协程实现惰性求值，代码简洁，可读性高。可以轻松生成无限序列。	协程有一定开销，调试可能比较困难。	需要惰性求值，且序列生成逻辑较为复杂的场景。尤其适合处理大数据集或无限序列。
Ranges (C++20)	可以与`generator`结合使用，实现更强大的序列处理能力。Ranges提供了丰富的序列操作符，可以对`generator`生成的序列进行过滤、转换等操作。	Ranges本身也需要一定的学习成本。	需要对序列进行复杂的转换和过滤操作，并且需要与其他Ranges库集成。

实际应用场景

读取大型文件： 逐行读取大型文本文件，避免一次性加载到内存。
处理网络数据流： 实时处理网络数据流，只处理当前需要的数据。
游戏开发： 生成游戏地图、粒子效果等，按需生成，提高性能。
数据分析： 处理大型数据集，只加载需要分析的数据，节省内存。
机器学习： 训练模型时，批量加载数据，避免内存溢出。

总结

C++23的generator是一个非常强大的工具，它简化了惰性求值序列的生成，提高了代码的可读性和可维护性。虽然协程有一定的开销，但在处理大数据集或无限序列时，generator的优势非常明显。希望今天的讲解能帮助大家更好地理解和使用generator，让你的C++代码更加优雅高效！

最后，留个小作业：

用generator实现一个生成素数的序列，并打印前20个素数。

各位，下次再见！

发表回复 取消回复

发表回复取消回复