企业官网建设流程全解析

1. 项目概述：从“差不多就行”到“必须精确”的随机数认知转变

在C++编程的日常里，生成随机数是一个看似简单、实则暗藏玄机的操作。很多开发者，尤其是初学者，在需要模拟掷骰子、抽奖或者生成测试数据时，第一反应可能就是写下rand() % 6这样的代码，期望得到一个0到5（或1到6）的均匀随机整数。代码能跑，结果看起来也“挺随机”，于是项目继续推进。然而，正是这种“差不多就行”的态度，为程序埋下了难以察觉的隐患——结果的分布可能并不公平，甚至在某些场景下会导致严重的逻辑错误或安全漏洞。这个项目标题直指这一普遍存在的认知误区与实践陷阱。

“C++随机数避坑指南”这个定位，意味着我们将超越简单的API调用手册，深入剖析随机数生成的底层原理与工程实践。核心矛盾在于古老的、源自C语言的rand()函数与现代C++标准库提供的<random>头文件之间的代际差异。rand() % N的做法为何不公平？其根源在于rand()生成的伪随机数序列的周期性、分布均匀性，以及取模运算引入的偏差。而std::mt19937，作为C++11引入的梅森旋转算法实现，代表了高质量、高性能、可预测的伪随机数生成器（PRNG），是解决上述问题的标准答案。但仅仅知道这个类名还不够，如何正确初始化、选择分布、管理其生命周期，才是“正确的打开方式”。

本文将从一个资深C++工程师的视角，彻底拆解随机数生成的坑与桥。我们不仅会用数学和代码证明rand() % 6的不公平性，更会手把手带你掌握std::mt19937及其伙伴们（如各种分布器std::uniform_int_distribution）的完整工作流。无论你是在开发游戏、进行科学模拟、构建加密相关模块，还是编写单元测试，对随机数的深刻理解与正确运用，都是代码质量与可靠性的重要基石。接下来，让我们拨开迷雾，一探究竟。

2. 深入剖析：为什么rand() % 6是一个糟糕的选择

要理解rand() % 6的问题，我们需要从rand()函数本身和取模运算的特性两方面入手。

2.1rand()函数的本质与历史局限

rand()是C标准库（<cstdlib>）中定义的函数，在C++中通常通过<cstdlib>或间接包含来使用。它的典型实现是线性同余生成器（LCG）。一个经典的LCG公式是：next = (previous * a + c) % m其中a,c,m是常数。rand()返回的是一个介于0到RAND_MAX之间的伪随机整数。RAND_MAX是一个编译时常量，在大多数系统上，它是32767（即 2^15 - 1）。

第一个问题：周期短，序列可预测。一个典型的LCG周期长度最多为m。如果实现不佳，周期可能更短，并且序列在低阶比特上可能表现出明显的规律性（例如，最低位在奇偶之间交替）。对于rand()，其周期长度通常就是RAND_MAX的量级，即大约3.2万。这意味着在生成了3万多个数字后，序列就会开始重复。对于需要大量随机数的应用（如蒙特卡洛模拟），这是完全不够的。

第二个问题：均匀性在全局范围内尚可，但局部可能不佳。LCG在整周期内，如果参数选择得当，可以做到均匀分布。但rand()的具体实现因库和平台而异，C/C++标准只规定了它的接口和行为的大致轮廓，并未规定其算法和质量。因此，不同环境下的rand()质量参差不齐。

2.2 取模运算%是如何引入偏差的

这是导致rand() % 6不公平的直接原因。为了简化，我们假设rand()是完美的，它均匀地生成0到RAND_MAX之间的每一个整数。

关键点在于：RAND_MAX + 1（即所有可能输出的总数）未必能被6整除。

让我们计算一下：在常见系统上，RAND_MAX = 32767。那么rand()可以产生32768个不同的值（0到32767）。当我们计算rand() % 6时，我们希望得到 0, 1, 2, 3, 4, 5 这6个结果，且每个结果出现的概率都是1/6 ≈ 16.666...%。

但实际情况呢？我们把32768除以6：32768 / 6 = 5461.333...这意味着不能整除。商是5461，余数是2。 具体来说：

• 有5462个rand()的输出值，它们模6的结果是0。
• 有5462个rand()的输出值，它们模6的结果是1。
• 有5461个rand()的输出值，它们模6的结果是2。
• 有5461个rand()的输出值，它们模6的结果是3。
• 有5461个rand()的输出值，它们模6的结果是4。
• 有5461个rand()的输出值，它们模6的结果是5。

我们来计算概率：

• P(0) = 5462 / 32768 ≈ 16.66% + 0.003%
• P(1) = 5462 / 32768 ≈ 16.66% + 0.003%
• P(2) = 5461 / 32768 ≈ 16.66% - 0.003%
• P(3) = 5461 / 32768 ≈ 16.66% - 0.003%
• P(4) = 5461 / 32768 ≈ 16.66% - 0.003%
• P(5) = 5461 / 32768 ≈ 16.66% - 0.003%

可以看到，结果0和1出现的概率比2,3,4,5略高。虽然这个绝对偏差很小（约0.003个百分点），但在统计学意义上，它破坏了均匀性。对于要求严格的模拟，或者当随机数被大量、反复使用时，这种微小的偏差会累积，导致结果偏离预期。

注意：这个偏差的大小取决于RAND_MAX和模数N。当N越大，或者RAND_MAX不是N的整数倍时，偏差可能更显著。例如，如果你用rand() % 1000，RAND_MAX=32767，那么有767个数字出现的概率会比其他的高。

一个更直观的“拒绝采样”思维实验：想象你有一个完美的均匀随机数生成器，可以生成[0, 32767]的整数。你想从中公平地得到一个[0, 5]的整数。最公平的做法是：如果生成的数落在[0, 32765]这个区间（因为32766是6的整数倍），我们就用%6；如果生成的数是32766或32767，我们就拒绝它，重新生成。rand() % 6没有这个“拒绝”步骤，它强行把最后两个数也映射了（32766->0, 32767->1），导致0和1多了一次出现的机会。

2.3 代码验证与可视化影响

让我们写一段简单的代码来验证这个偏差。虽然一次运行可能看不出来，但通过大量采样，统计规律就会显现。

#include <iostream> #include <cstdlib> #include <ctime> #include <vector> int main() { std::srand(static_cast<unsigned int>(std::time(nullptr))); // 用时间初始化种子 const int numTrials = 1000000; // 投掷一百万次骰子 const int numSides = 6; std::vector<int> counts(numSides, 0); for (int i = 0; i < numTrials; ++i) { int roll = std::rand() % numSides; // 有偏差的方法 counts[roll]++; } std::cout << "使用 rand() % 6 模拟掷骰子 " << numTrials << " 次的结果：\n"; for (int i = 0; i < numSides; ++i) { double percentage = (static_cast<double>(counts[i]) / numTrials) * 100.0; std::cout << "点数 " << i+1 << ": " << counts[i] << " 次 (" << percentage << "%)\n"; } // 计算理论期望值 double expected = numTrials / static_cast<double>(numSides); std::cout << "\n理论期望每个点数出现次数: " << expected << std::endl; return 0; }

运行多次，你可能会观察到类似下面的输出（具体数字每次运行不同，但趋势一致）：

使用 rand() % 6 模拟掷骰子 1000000 次的结果： 点数 1: 167318 次 (16.7318%) 点数 2: 166953 次 (16.6953%) 点数 3: 166521 次 (16.6521%) 点数 4: 166380 次 (16.638%) 点数 5: 166201 次 (16.6201%) 点数 6: 166627 次 (16.6627%) 理论期望每个点数出现次数: 166666.667

虽然差异看似只有千分之一左右，但在严格的统计检验下，这足以证明分布不是均匀的。对于需要高度公平性的应用（如赌博游戏算法、高精度科学模拟），这是不可接受的。

实操心得：不要抱有侥幸心理，认为“偏差很小，不影响”。在软件工程中，尤其是涉及概率、金融或安全的代码里，使用有已知缺陷的方法是一种不负责任的行为。正确的做法是从一开始就采用无偏差的、标准化的工具。

3. 现代C++的解决方案：<random>库全景解析

C++11标准引入了<random>库，这是一套设计精良、模块化的随机数生成工具。它明确区分了随机数引擎（生成原始随机比特序列）和随机数分布（将引擎的输出映射到所需的统计分布上）。这种分离带来了极大的灵活性和正确性保障。

3.1 核心组件架构

<random>库主要包含三类组件：

1. 随机数引擎（Engine）：伪随机数生成器的实现。它是有状态的，通过调用operator()来生成一个原始的无符号整数。
   • 例如：std::mt19937,std::mt19937_64（梅森旋转），std::minstd_rand（改进的LCG），std::ranlux48（高保真度引擎）。
2. 随机数引擎适配器（Engine Adaptor）：修饰另一个引擎，改变其输出特性。
   • 例如：std::discard_block_engine（丢弃部分输出），std::independent_bits_engine（生成特定位数的输出）。
3. 随机数分布（Distribution）：无状态的函数对象，它接收引擎生成的原始值，并将其转换为遵循特定概率分布（如均匀、正态、泊松）的值。
   • 例如：std::uniform_int_distribution<int>（整数均匀分布），std::uniform_real_distribution<double>（浮点数均匀分布），std::normal_distribution<double>（正态分布）。

这种架构的妙处在于，你可以像搭积木一样组合它们。例如，std::shuffle算法需要的是一个满足均匀随机数生成器概念的对象，你可以直接传递一个std::mt19937实例，因为它生成的原始值在自身周期内是均匀的；但如果你需要特定范围的整数，就应该组合std::mt19937和std::uniform_int_distribution。

3.2 为什么是std::mt19937？

在众多引擎中，std::mt19937（Mersenne Twister by Matsumoto and Nishimura, 1997）是最常被推荐用于通用目的的一个。原因如下：

• 超长周期：它的周期长度是 2^19937 - 1，这是一个天文数字（约4.3 x 10^6001），对于任何现实应用都远远足够，彻底解决了rand()周期短的问题。
• 高维度均匀分布：它的名字“梅森旋转”就暗示了其算法特性，能在高维空间（最多623维）产生均匀分布的点，这对于蒙特卡洛方法等模拟非常有利。
• 性能良好：在现代CPU上，它的生成速度很快。
• 经过充分研究：该算法被广泛研究和使用，其性质已被充分了解。C++标准库的实现保证了可移植性和一致性。

当然，它并非完美无缺。std::mt19937内部状态较大（约2.5KB），初始化相对较慢，并且不适合用于密码学（因为给定足够长的输出序列，其状态可以被反向推导）。但对于绝大多数游戏、模拟、测试等场景，它是绝佳选择。

std::mt19937_64是其64位版本，周期为2^19937-1，但每次生成64位随机数。如果主要需要64位随机数，使用它可以避免拼接操作，可能更高效。

3.3 关键分布器：std::uniform_int_distribution如何保证公平

这才是解决rand() % N不公平问题的关键。std::uniform_int_distribution<int> dist(a, b)会生成一个在闭区间[a, b]内均匀分布的整数。

它的内部实现采用了类似前面提到的“拒绝采样”思想，但通常更高效。标准库的实现会确保：

1. 无论底层引擎的RAND_MAX等效值是多少，它都能通过算法处理，使得最终输出区间[a, b]内的每一个整数被选中的概率严格相等。
2. 它高效地利用了引擎输出的随机比特，减少了浪费。

当你调用dist(engine)时，分布器会从引擎获取足够的随机比特，并经过一个转换过程，确保结果无偏差。这是<random>库提供的核心价值之一——将生成无偏随机数的复杂性封装起来，让开发者可以安全、简单地调用。

4.std::mt19937的正确打开方式：从初始化到使用

知道了原理，我们来具体看看如何正确使用它。错误的使用方式会抵消掉它的所有优点。

4.1 初始化：种子（Seed）的学问

随机数引擎需要初始状态，这个初始值就是种子。相同的种子必然产生相同的随机数序列，这对于重现程序行为（如调试、测试）至关重要。但对于大多数应用，我们需要每次运行都不同的序列。

错误做法：使用默认构造函数

std::mt19937 gen; // 默认初始化，通常使用固定种子（可能是1或0）

这会导致每次程序运行都产生完全相同的序列，失去了随机性。

正确做法：使用真随机数设备设置种子C++11提供了std::random_device。它试图访问操作系统的真随机数源（如/dev/urandom或CryptGenRandom）。这通常是获取高质量种子最简单的方法。

#include <random> std::random_device rd; // 用于获取真随机数种子 std::mt19937 gen(rd()); // 用 rd() 返回的随机数初始化引擎

std::random_device的operator()返回一个unsigned int作为种子。对于std::mt19937这样拥有巨大状态空间的引擎，单个unsigned int（通常32位）作为种子可能“喂不饱”它，只能初始化其状态的一小部分。虽然实践中这通常没问题，但对于要求极高的场景，可以用多个随机数来填充状态。

更健壮的初始化（适用于std::mt19937）：std::mt19937的内部状态是一个有624个unsigned int的数组。我们可以用std::random_device生成足够多的随机数来填充它。

#include <random> #include <array> std::random_device rd; std::array<unsigned int, std::mt19937::state_size> seed_data; std::generate(seed_data.begin(), seed_data.end(), std::ref(rd)); std::seed_seq seq(seed_data.begin(), seed_data.end()); // seed_seq 可以更好地混合种子 std::mt19937 gen(seq);

std::seed_seq是一个辅助类，它能对提供的种子序列进行“搅拌”，产生一个更高质量的初始化状态，尤其适合std::mt19937这类需要大量初始状态的引擎。

注意：std::random_device在某些旧编译器或平台上可能被实现为伪随机引擎（即，它本身也是确定性的）。在主流现代平台（Linux/macOS/Windows 上的 GCC, Clang, MSVC）上，它通常能连接到系统熵源。如果你非常关心种子的不可预测性，需要检查你的编译环境文档。

4.2 生成随机数：组合引擎与分布

初始化好引擎后，不要直接使用引擎的输出！应该将其与一个分布器组合使用。

生成一个均匀的整数随机数（例如，模拟掷一个六面骰子，得到1-6）：

std::uniform_int_distribution<int> dist(1, 6); // 定义分布，范围[1, 6] int dice_roll = dist(gen); // 生成随机数

每次调用dist(gen)，分布器dist都会从引擎gen中“消耗”一些随机比特，并返回一个符合均匀分布的整数。

生成一个均匀的浮点数随机数（例如，生成[0, 1)区间的随机小数）：

std::uniform_real_distribution<double> dist(0.0, 1.0); // 范围[0.0, 1.0) double random_double = dist(gen);

注意std::uniform_real_distribution默认是半开区间[a, b)，即包含a，不包含b。这是为了与许多数学定义和STL的区间惯例保持一致。

4.3 性能与线程安全

• 性能：对于需要生成大量随机数的循环，在循环外定义好引擎和分布对象，在循环内只调用dist(gen)。避免在循环内反复构造这些对象。
• 线程安全：C++标准库中的随机数引擎和分布对象不是线程安全的。如果多个线程共享同一个引擎对象并调用它，会导致数据竞争和未定义行为。正确的做法是：
  1. 每个线程使用自己独立的引擎实例（用不同的种子初始化）。
  2. 或者，使用一个全局引擎，但通过互斥锁（如std::mutex）保护对它的访问。方法1通常性能更好，也更简单。

每个线程独立实例的示例：

#include <random> #include <thread> #include <vector> void thread_task(int thread_id) { // 使用 thread_id 和当前时间等组合成种子，确保不同线程种子不同 unsigned int seed = static_cast<unsigned int>(std::hash<std::thread::id>{}(std::this_thread::get_id())) ^ static_cast<unsigned int>(std::chrono::system_clock::now().time_since_epoch().count()); std::mt19937 local_gen(seed); std::uniform_int_distribution<int> dist(1, 100); for (int i = 0; i < 5; ++i) { std::cout << "Thread " << thread_id << ": " << dist(local_gen) << std::endl; } } int main() { std::vector<std::thread> threads; for (int i = 0; i < 3; ++i) { threads.emplace_back(thread_task, i); } for (auto& t : threads) { t.join(); } return 0; }

5. 实战对比与迁移指南

让我们通过一个完整的例子，对比旧式rand()用法和现代<random>库用法，并展示如何将旧代码迁移到新标准。

5.1 完整示例：公平的骰子模拟器

#include <iostream> #include <random> #include <vector> #include <iomanip> #include <map> // 使用现代C++ <random> 库的正确方式 void fair_dice_simulation(int numRolls) { std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<int> dist(1, 6); std::map<int, int> frequency; for (int i = 0; i < numRolls; ++i) { int roll = dist(gen); frequency[roll]++; } std::cout << "公平骰子 (" << numRolls << " 次投掷) - 使用 std::uniform_int_distribution:\n"; for (const auto& [value, count] : frequency) { double percent = (static_cast<double>(count) / numRolls) * 100.0; std::cout << "点数 " << value << ": " << std::setw(6) << count << " 次 (" << std::fixed << std::setprecision(3) << percent << "%)\n"; } std::cout << std::endl; } // 旧式的不公平方法（仅用于对比） void biased_dice_simulation(int numRolls) { std::srand(static_cast<unsigned int>(std::time(nullptr))); std::map<int, int> frequency; for (int i = 0; i < numRolls; ++i) { int roll = (std::rand() % 6) + 1; // 有偏差的取模方法 frequency[roll]++; } std::cout << "有偏差骰子 (" << numRolls << " 次投掷) - 使用 rand() % 6:\n"; for (const auto& [value, count] : frequency) { double percent = (static_cast<double>(count) / numRolls) * 100.0; std::cout << "点数 " << value << ": " << std::setw(6) << count << " 次 (" << std::fixed << std::setprecision(3) << percent << "%)\n"; } std::cout << std::endl; } int main() { const int numRolls = 1000000; // 一百万次 // 为了公平比较，先运行有偏差的，再运行公平的 biased_dice_simulation(numRolls); fair_dice_simulation(numRolls); // 也可以运行多次，观察统计波动 return 0; }

运行这个程序，你会看到fair_dice_simulation的结果中，各点数的频率更紧密地围绕在16.667%附近，而biased_dice_simulation的结果则可能显示出可观测的系统性偏差（尤其是当投掷次数极大时，或RAND_MAX与6的整除性更差时）。

5.2 旧代码迁移模式

如果你维护着一个使用大量rand()的旧代码库，逐步迁移是可行的。以下是一些常见的替换模式：

迁移步骤建议：

1. 识别用途：分析每个rand()调用是为了什么分布（均匀整数、均匀浮点数、正态分布等）。
2. 局部化替换：在函数或类内部，将std::srand和rand()替换为局部引擎和分布对象。这避免了全局状态的副作用。
3. 考虑线程：如果代码是多线程的，确保每个线程有自己的引擎，或对共享引擎加锁。
4. 测试验证：对于关键逻辑，使用固定的种子进行回归测试，确保迁移后的随机行为在可控范围内与之前一致（如果之前逻辑依赖有偏差的随机，那可能需要重新审视逻辑）。

5.3 进阶应用：生成非均匀分布

<random>库的强大之处在于提供了丰富的分布。例如，生成符合正态分布（高斯分布）的随机数：

#include <random> #include <iostream> #include <vector> #include <algorithm> #include <cmath> int main() { std::random_device rd; std::mt19937 gen(rd()); // 生成均值为100，标准差为15的正态分布随机数（模拟IQ分数） std::normal_distribution<double> iq_dist(100.0, 15.0); std::vector<double> iq_scores; for (int i = 0; i < 1000; ++i) { iq_scores.push_back(iq_dist(gen)); } // 简单统计：计算样本均值和标准差 double sum = std::accumulate(iq_scores.begin(), iq_scores.end(), 0.0); double mean = sum / iq_scores.size(); double sq_sum = std::inner_product(iq_scores.begin(), iq_scores.end(), iq_scores.begin(), 0.0); double stdev = std::sqrt(sq_sum / iq_scores.size() - mean * mean); std::cout << "样本均值: " << mean << std::endl; std::cout << "样本标准差: " << stdev << std::endl; // 查看分布：粗略统计落在几个区间内的人数 std::map<int, int> bins; // 区间 -> 计数 for (double score : iq_scores) { int bin = static_cast<int>(std::round(score / 10.0)) * 10; // 按10分一个区间分组 bins[bin]++; } for (const auto& [bin, count] : bins) { std::cout << "IQ ~" << bin << ": " << std::string(count / 5, '*') << " (" << count << "人)\n"; } return 0; }

这个例子生成了1000个服从正态分布的IQ分数，并进行了简单的统计分析。你可以轻松替换成其他分布，如std::poisson_distribution（泊松分布）、std::exponential_distribution（指数分布）等，来满足不同领域的模拟需求。

6. 常见陷阱、性能考量与最佳实践

即使使用了<random>库，如果使用不当，仍然会遇到问题。下面总结一些实战中的坑和技巧。

6.1 陷阱一：在循环内重复构造引擎和分布

错误示例：

for (int i = 0; i < 1000000; ++i) { std::random_device rd; std::mt19937 gen(rd()); // 每次循环都新建引擎，开销巨大！ std::uniform_int_distribution<int> dist(1, 6); int roll = dist(gen); // ... 使用 roll }

std::random_device和std::mt19937的构造成本相对较高。在循环内反复构造会严重拖慢程序。

正确做法：在循环外一次性构造好。

std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<int> dist(1, 6); for (int i = 0; i < 1000000; ++i) { int roll = dist(gen); // 只调用生成函数 // ... 使用 roll }

6.2 陷阱二：误用std::default_random_engine

std::default_random_engine是一个别名，具体指向哪种引擎由实现定义。它可能是std::mt19937，也可能是std::minstd_rand或其他。它的优点是名字短，但缺点是不可移植——在不同编译器或平台上，你的程序可能使用不同的引擎，从而产生不同的随机数序列。这对于需要可重现结果（如科学计算、单元测试）的程序是灾难性的。

建议：明确指定你需要的引擎，如std::mt19937，以保证代码行为和性能的可移植性与可预期性。

6.3 陷阱三：分布器对象的复用与重置

分布器对象通常是无状态的（除了少数如std::discrete_distribution在构造时需要参数）。你可以安全地用一个分布器对象配合多个引擎，或者反复使用同一个分布器-引擎对。

如果需要精确重现一段序列，你需要保存引擎的状态，而不是分布器的状态。分布器只是算法。

std::mt19937 gen1(seed); std::uniform_int_distribution<int> dist(1, 100); // 生成一些数 int a = dist(gen1); int b = dist(gen1); // 保存引擎状态 std::stringstream state_stream; state_stream << gen1; // 继续使用 gen1 ... int c = dist(gen1); // 后来，另一个引擎恢复到之前的状态 std::mt19937 gen2; state_stream >> gen2; // 此时从 gen2 生成的序列，将从之前保存的断点继续 int d = dist(gen2); // d 将等于 c

std::seed_seq也可以用来从一个已知的种子序列精确复现整个引擎状态。

6.4 性能考量与引擎选择

• std::mt19937：通用首选，在质量和速度间取得了良好平衡。状态大（~2.5KB），初始化慢。
• std::mt19937_64：64位版本，如果需要大量64位随机数且平台支持64位运算高效，可以考虑。
• std::ranlux48/std::ranlux24：高质量“奢侈”引擎，速度较慢，但随机性质量极高，适用于对统计特性要求极严的模拟。
• std::minstd_rand：改进的LCG，速度极快，状态极小（通常一个unsigned int），但周期和质量远不如MT。适用于对随机数质量要求不高，但需要极快生成速度的场景（如游戏中的粒子效果）。

选择建议：除非有明确的性能瓶颈且经过 profiling 证实随机数生成是热点，否则默认使用std::mt19937。它的性能对于绝大多数应用已经足够好。

6.5 最佳实践总结

1. 弃用rand()和srand()：在新项目中绝不使用，在旧项目中计划迁移。
2. 使用<random>库：明确区分引擎和分布。
3. 引擎选择：通用目的选择std::mt19937，追求极致性能且要求不高时考虑std::minstd_rand，追求最高质量时考虑std::ranlux48。
4. 种子初始化：使用std::random_device获取种子。对于std::mt19937，考虑使用std::seed_seq和多个随机数进行充分初始化。
5. 使用分布器：总是通过分布器（如std::uniform_int_distribution）来获取特定分布的随机数，不要直接对引擎输出进行取模等运算。
6. 对象生命周期：在循环外构造引擎和分布对象，避免重复初始化开销。
7. 线程安全：为每个线程提供独立的引擎实例。
8. 可重现性：通过固定种子或保存引擎状态来实现随机序列的复现，便于调试和测试。
9. 了解需求：清楚你的应用需要什么样的随机性（统计质量、速度、不可预测性、可重现性），据此选择合适的组件。

随机数生成是基础，但绝非 trivial。在现代C++中，我们拥有了强大且易用的工具。花一点时间理解并正确使用<random>库，能够从根本上提升程序的正确性、可靠性和可维护性。从今天起，和rand() % N说再见吧。