std::generate：让容器“自己长出数据”的轻量填充术

写C++时，你有没有过这种时刻：手头有个std::vector<int>，要填100个随机数、100个斐波那契值，或者100个带递增ID的结构体？一想到得写个for循环、搞个计数器、再挨个push_back，手指就有点发懒——尤其当逻辑本身不复杂，只是“重复执行某件事”时。

这时候，std::generate不是锦上添花的玩具，而是省掉三行胶水代码、避免下标越界、还能一眼看清“生成意图”的实用工具。

它不造新容器，也不改已有元素；它只做一件事：对指定范围内的每个位置，调用一个可调用对象（函数、lambda、仿函数），把返回值原地写进去。关键在于——写入动作由算法控制，逻辑由你定义，两者解耦得干净利落。

比如初始化一个含10个元素的数组，让它们依次是 2, 4, 6, 8…：

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> v(10);
    int val = 2;
    std::generate(v.begin(), v.end(), [&val]() mutable {
        int result = val;
        val += 2;
        return result;
    });

    // 输出：2 4 6 8 10 12 14 16 18 20
    for (int x : v) std::cout << x << " ";
}

注意两个细节：mutable关键字必不可少——因为lambda默认按值捕获，若不加mutable，val就是只读副本，自增无效；容器必须预先分配好空间——generate不会扩容，它只往已有内存里填。这点和std::fill一致，但比std::iota更自由：后者只能填等差序列，而generate能填任何你能想出来的规律。

真正让它“活起来”的，是和状态封装的配合。比如生成前N个质数，传统写法容易把筛法逻辑和容器填充搅在一起。用generate，可以清晰分层：

class PrimeGenerator {
    std::vector<int> primes;
    int candidate = 2;
public:
    int operator()() {
        while (true) {
            bool is_prime = true;
            for (int p : primes) {
                if (p * p > candidate) break;
                if (candidate % p == 0) {
                    is_prime = false;
                    break;
                }
            }
            if (is_prime) {
                primes.push_back(candidate);
                return candidate++;
            }
            ++candidate;
        }
    }
};

// 使用：
std::vector<int> first_15_primes(15);
std::generate(first_15_primes.begin(), first_15_primes.end(), PrimeGenerator{});

这里没有循环变量、没有索引管理，只有“我要一个质数”的声明式表达。PrimeGenerator把状态（已知质数列表、当前候选数）全锁在自己内部，外部只管取，不操心怎么算——这正是现代C++推崇的“关注点分离”。

再看一个更贴近实际开发的场景：填充日志结构体。假设你有一组操作记录，需要为每条记录附上单调递增的序列号、当前时间戳，以及一个基于内容计算的简短哈希：

struct LogEntry {
    size_t seq;
    std::chrono::system_clock::time_point ts;
    std::string content;
    uint32_t hash;
};

std::vector<std::string> raw_logs = {"login", "fetch_data", "save_config", "logout"};
std::vector<LogEntry> entries(raw_logs.size());

size_t seq = 1;
auto now = std::chrono::system_clock::now();
std::generate(entries.begin(), entries.end(), [&, i = 0]() mutable -> LogEntry {
    auto& s = raw_logs[i++];
    return {
        seq++,
        now + std::chrono::milliseconds(i), // 每条微差几毫秒，模拟真实时序
        s,
        std::hash<std::string>{}(s) // 简化版哈希
    };
});

[&, i = 0] mutable这个捕获组合很关键：&让lambda能读写外部的seq和now，i = 0提供一个局部计数器（避免依赖全局或静态变量），mutable保证i++生效。整段代码读下来，像在描述“每条日志该长什么样”，而不是“怎么一步步把它塞进内存”。

有人会问：generate和transform有什么区别？简单说：generate不依赖输入数据，它凭空“生成”；transform需要源范围，是“转换已有的东西”。如果你有原始字符串数组，想转成大写，用transform；但如果你只想生成100个随机UUID，没有输入源，generate就是自然选择。

还有一点常被忽略：generate支持任意迭代器类型。它不仅能填vector，也能填deque、array，甚至是你自己写的容器（只要提供符合要求的迭代器）。这意味着——当你封装一个领域专用容器时，generate可以成为其标准填充接口的一部分，无需暴露底层存储细节。

最后提醒一个易踩的坑：别在多线程环境下无保护地共享同一个生成器实例。比如多个线程同时调用同一个PrimeGenerator对象的operator()，结果未定义。解决方法很简单：每个线程用独立实例，或用thread_local修饰生成器对象。

回到开头那个问题：为什么值得为填充容器学一个新算法？因为C++里最值得省下的，从来不是CPU时间，而是人脑在胶水代码上反复校验的注意力。generate不炫技，但它把“我要什么”和“怎么给”切得足够利落——当你第三次写类似for (int i = 0; i < n; ++i) v[i] = f(i);时，不妨试试让它退场，换一行std::generate来站岗。
那点少写的括号和分号，最终都会变成你调试时多出的一次深呼吸。