企业官网建设流程全解析

1. 从 rand 到 mt19937：C++ 随机数到底该用哪个

很多人写 C++ 随机数，第一反应就是rand()。这几乎是所有 C++ 教材里最早出现的随机数函数，简单、直接、不用额外头文件。但如果你真的在项目里用过rand()，大概率会遇到两个让人头疼的问题：一是每次运行结果都一样，二是随机数的范围总是不太均匀。这两个问题背后，其实牵扯到 C++ 随机数体系里几个完全不同的层次。

C++ 的随机数能力大致可以分成三代。第一代是继承自 C 语言的rand()和srand()，定义在<cstdlib>里；第二代是 C++11 引入的<random>库，包含随机数引擎、分布器和适配器；第三代则是在 C++11 基础上的扩展，比如std::seed_seq、std::random_device的更好利用，以及各种引擎的取舍。这三代并不是简单的替代关系，而是各有适用场景。

先说说rand()为什么容易出问题。rand()返回的是一个int，范围在0到RAND_MAX之间。RAND_MAX的具体值由实现决定，标准只保证它至少是 32767。也就是说，在某些平台上，rand()能产生的不同值可能只有三万多。如果你需要生成一个很大的随机数，或者需要高精度的浮点随机数，rand()的粒度就明显不够了。

更麻烦的是取模运算。很多人写rand() % 100来生成 0 到 99 的随机数，这看起来没问题，但实际上会引入偏差。假设RAND_MAX是 32767，那么rand() % 100的结果中，0 到 67 出现的概率会比 68 到 99 略高一点。因为 32767 除以 100 的余数是 67，前 68 个余数会多出现一次。这个偏差在RAND_MAX较小的时候尤其明显。如果RAND_MAX是 32767，偏差大约是千分之几，看起来不大，但在需要严格均匀分布的场合，比如蒙特卡洛模拟或者抽奖程序，这就是个隐患。

那srand()呢？它的作用是设置随机数种子。如果不调用srand()，rand()会使用默认种子 1，所以每次程序运行产生的序列完全一样。很多人用srand(time(nullptr))来让种子随时间变化，这确实能让每次运行结果不同。但time(nullptr)的精度是秒，如果程序在一秒内启动多次，比如在脚本里循环调用，那么这些次运行的随机序列会完全相同。这个问题在自动化测试或者批量生成数据时特别容易踩坑。

C++11 的<random>库就是为了解决这些问题而设计的。它把随机数生成拆成了两个独立的部分：引擎和分布。引擎负责产生均匀的、范围固定的整数序列，分布负责把这些整数映射到你需要的范围或分布类型。这种分离让代码更清晰，也更容易控制质量。

常用的引擎有std::mt19937、std::mt19937_64、std::minstd_rand、std::ranlux24_base等。其中std::mt19937是最常用的，它是梅森旋转算法的一个实现，周期长达 2^19937-1，产生的随机数质量很高，速度也不错。std::mt19937_64是它的 64 位版本，适合需要大范围随机数的场景。std::minstd_rand是线性同余引擎，周期短、速度快，但质量一般，适合对随机性要求不高的场合。

分布器方面，std::uniform_int_distribution用于生成指定范围内的均匀整数，std::uniform_real_distribution用于生成指定范围内的均匀浮点数，std::normal_distribution用于生成正态分布的浮点数，std::bernoulli_distribution用于生成布尔值。这些分布器会自动处理边界和偏差问题，比手动取模要可靠得多。

还有一个重要的组件是std::random_device。它通常用于获取一个真正的随机种子，而不是像time(nullptr)那样只精确到秒。std::random_device的实现可能依赖硬件熵源，也可能只是伪随机，但标准要求它至少能提供一个不确定的种子。用它来初始化std::mt19937，可以避免种子重复的问题。

那么，到底该用哪个？我的建议是：新项目一律用<random>库，优先选择std::mt19937配合std::random_device做种子。如果只是写个小练习或者对随机性要求极低，rand()也不是不能用，但要知道它的局限。如果是在维护老代码，看到rand() % n的写法，可以考虑逐步替换成<random>的写法，尤其是在发现随机结果有偏差的时候。

下面这张表可以帮你快速对比几种常见方案：

选型的时候还要注意一点：std::random_device在某些平台上可能很慢，甚至可能阻塞。所以不要用它直接生成大量随机数，而是用它生成一个种子，然后交给std::mt19937去产生序列。这是最常见的做法，也是比较稳妥的做法。

2. rand 与 srand 的经典陷阱：为什么你的随机数总是不随机

rand()和srand()是 C++ 里最古老的随机数工具，几乎每本入门书都会讲。但正因为太常见，很多细节被忽略了，导致写出来的代码看起来没问题，实际跑起来却各种不对劲。这一节我把几个最典型的坑拆开讲，你可以对照自己的代码看看有没有中招。

2.1 不调用 srand 的后果：每次运行都一样

这是最基础的问题，但也是最容易被忽视的。rand()在没有调用srand()的情况下，会使用默认种子 1。这意味着每次程序启动，rand()产生的序列是完全相同的。比如下面这段代码：

#include <cstdlib> #include <iostream> int main() { for (int i = 0; i < 5; ++i) { std::cout << rand() % 100 << " "; } std::cout << std::endl; return 0; }

不管你运行多少次，输出都是同一串数字。这在调试的时候可能还挺方便，但在实际使用中就是灾难。比如你写一个猜数字游戏，每次答案都一样，玩家第二次就猜到了。

解决办法是调用srand()设置种子。最常见的写法是srand(time(nullptr))，用当前时间作为种子。这样每次运行的时间不同，种子就不同，序列也就不同了。

2.2 time(nullptr) 的秒级精度问题

srand(time(nullptr))看起来解决了问题，但它有一个隐藏的缺陷：time(nullptr)返回的是从某个固定时间点开始的秒数，精度只有一秒。如果你的程序在一秒内被多次启动，比如在 shell 脚本里循环执行，那么这些次运行的种子完全相同，随机序列也完全相同。

我遇到过好几次这种情况。有一次写了个批量生成测试数据的工具，用srand(time(nullptr))做种子，然后在脚本里循环调用了一百次。结果生成的数据有一大半是重复的，排查了半天才发现是种子重复了。后来改成用std::random_device或者把进程 ID 也混进去，问题才解决。

如果你非要用time(nullptr)，一个改进办法是结合其他信息，比如getpid()或者高精度时钟。但更推荐的做法是直接用<random>库的std::random_device，它专门就是干这个的。

2.3 取模偏差：rand() % n 的均匀性陷阱

rand() % n是最常见的随机数范围限定写法，但它有一个数学上的缺陷。假设RAND_MAX是 32767，你想生成 0 到 99 的随机数，那么rand() % 100的结果中，0 到 67 每个数出现的次数会比 68 到 99 多一次。因为 32767 = 327 * 100 + 67，前 68 个余数（0 到 67）会对应 328 个原始值，而后 32 个余数（68 到 99）只对应 327 个原始值。

这个偏差有多大？对于RAND_MAX = 32767和n = 100，偏差大约是 0.3%。看起来很小，但在大量采样的时候会显现出来。比如你做一百万次采样，0 到 67 每个数大约会出现 10030 次，而 68 到 99 每个数大约出现 9970 次。差距虽然不大，但在需要严格均匀的场合，比如抽奖或者模拟，这就是个问题。

更严重的是当n接近RAND_MAX的时候。比如RAND_MAX是 32767，你写rand() % 30000，那么 0 到 2767 出现的概率会是其他数的两倍。这个偏差就非常明显了。

正确的做法是使用拒绝采样法。思路是：先计算一个阈值，把RAND_MAX中不能均匀分配的部分去掉，然后不断生成随机数直到落在有效范围内。<random>库里的std::uniform_int_distribution内部就是这么做的，所以你直接用分布器就不用操心这个问题。

如果你非要用rand()，可以这样写：

int rand_range(int min, int max) { int range = max - min + 1; int limit = RAND_MAX - (RAND_MAX % range); int r; do { r = rand(); } while (r >= limit); return min + r % range; }

这段代码通过拒绝掉那些会导致偏差的值，保证了均匀性。但说实话，既然 C++11 已经提供了<random>，没必要再自己手写这些。

2.4 线程安全问题：rand 在多线程下的表现

rand()和srand()不是线程安全的。标准里没有要求它们支持多线程，大多数实现使用的是一个全局状态。如果多个线程同时调用rand()，可能会产生数据竞争，导致未定义行为。即使没有崩溃，随机数的质量也会下降。

如果你在多线程环境里需要随机数，每个线程应该有自己的随机数引擎。<random>库的引擎对象是值语义的，可以每个线程持有一个，互不干扰。种子可以用std::random_device生成，或者用线程 ID 加上时间戳来构造。

#include <random> #include <thread> #include <iostream> void worker(int id) { std::random_device rd; std::mt19937 gen(rd() + id); std::uniform_int_distribution<int> dist(1, 100); for (int i = 0; i < 5; ++i) { std::cout << "Thread " << id << ": " << dist(gen) << std::endl; } } int main() { std::thread t1(worker, 1); std::thread t2(worker, 2); t1.join(); t2.join(); return 0; }

这样每个线程有自己的引擎和种子，不会互相干扰。注意种子里加了线程 ID，是为了避免多个线程在同一秒内用random_device拿到相同种子（虽然概率很低，但加上更保险）。

3. C++11 random 库的正确打开方式

<random>库是 C++11 带来的重要更新，它把随机数生成拆成了引擎和分布两部分，让代码更清晰、更可控。但很多人第一次用的时候会觉得有点繁琐，不如rand() % n来得直接。这一节我把<random>的核心用法和常见组合讲清楚，你照着写就能用。

3.1 引擎、分布、种子的三角关系

<random>库的核心概念有三个：引擎、分布、种子。

引擎是随机数的来源，它产生的是均匀分布的整数序列。常用的引擎有std::mt19937、std::mt19937_64、std::minstd_rand等。引擎的名字里的数字通常表示它的周期或者状态大小，比如mt19937的周期是 2^19937-1。

分布是把引擎产生的整数映射到目标范围或分布类型。比如std::uniform_int_distribution<int>把引擎输出映射到指定整数区间，std::uniform_real_distribution<double>映射到浮点区间，std::normal_distribution<double>映射到正态分布。

种子是引擎的初始状态。同一个引擎，同样的种子，产生的序列完全相同。所以种子的选择很重要。std::random_device通常用来生成种子，因为它能提供不确定的值。

这三者的关系可以用一句话概括：用种子初始化引擎，把引擎传给分布，分布输出你需要的随机数。

#include <random> #include <iostream> int main() { std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<int> dist(1, 6); for (int i = 0; i < 10; ++i) { std::cout << dist(gen) << " "; } std::cout << std::endl; return 0; }

这段代码模拟掷骰子，输出 1 到 6 的随机数。rd()生成种子，gen是引擎，dist是分布。每次调用dist(gen)就产生一个随机数。

3.2 uniform_int_distribution 的边界处理

std::uniform_int_distribution的区间是闭区间，也就是说std::uniform_int_distribution<int> dist(1, 6)会产生 1、2、3、4、5、6，每个数的概率相等。这一点和rand() % 6 + 1不同，后者在RAND_MAX不是 6 的倍数时会有偏差。

分布器内部使用拒绝采样来保证均匀性，所以你不需要自己处理边界。但有一点要注意：分布器的operator()会修改引擎的状态，所以同一个分布器可以重复使用，但引擎不能是 const 的。

如果你需要一个左闭右开的区间，比如[0, n)，可以写std::uniform_int_distribution<int> dist(0, n - 1)。C++ 的分布器没有直接支持半开区间的接口，需要自己减一。

3.3 生成浮点随机数的精度控制

std::uniform_real_distribution<double>用于生成浮点随机数。它的区间是[a, b)，也就是包含下界，不包含上界。这一点和整数分布不同，整数分布是闭区间。

std::uniform_real_distribution<double> dist(0.0, 1.0); double x = dist(gen);

这段代码生成[0.0, 1.0)之间的浮点数。注意上界 1.0 是取不到的，但实际能取到的最大值非常接近 1.0。

浮点随机数的精度取决于引擎的输出位数和分布的实现。std::mt19937产生 32 位整数，映射到 double 的时候，精度大约是 2^-32，对于大多数应用足够了。如果需要更高精度，可以用std::mt19937_64，它产生 64 位整数，精度更高。

有一个常见的误区是用rand() / (double)RAND_MAX来生成浮点随机数。这样做的问题是RAND_MAX通常只有 32767，精度只有 2^-15 左右，而且上界 1.0 是能取到的，和uniform_real_distribution的半开区间不一致。如果代码里假设了上界取不到，就可能出 bug。

3.4 用 random_device 做种子的正确姿势

std::random_device是<random>库里唯一能提供不确定随机数的组件。它的operator()返回一个unsigned int，可以用作种子。

但std::random_device有一个问题：在某些平台上，它可能很慢，甚至可能阻塞。比如在某些 Linux 系统上，它依赖/dev/random，而/dev/random在熵不足时会阻塞。虽然后来很多系统改成了/dev/urandom的行为，但为了保险，最好不要用它直接生成大量随机数。

正确的用法是用它生成一个种子，然后交给std::mt19937：

std::random_device rd; std::mt19937 gen(rd());

如果担心rd()返回的值范围不够，可以用std::seed_seq来混合多个值：

std::random_device rd; std::seed_seq seed{rd(), rd(), rd(), rd(), rd(), rd(), rd(), rd()}; std::mt19937 gen(seed);

std::seed_seq会把多个种子值混合成一个高质量的种子序列，适合用于初始化引擎。std::mt19937的状态有 624 个 32 位整数，用seed_seq可以更充分地初始化。

还有一个细节：std::random_device在某些实现里可能不是真正的随机，而是伪随机。标准允许这种情况，但要求它至少能提供不确定的值。如果你需要密码学安全的随机数，<random>库是不够的，需要用专门的密码学库。但对于一般的模拟、游戏、测试数据生成，std::random_device加std::mt19937已经足够了。

4. 不同场景下的随机数方案选型

随机数的需求千差万别，有的只需要一个简单的 0 到 100 的整数，有的需要正态分布的浮点数，有的需要不重复的序列，有的需要密码学安全。这一节我按场景来梳理，每种场景给出推荐方案和代码示例。

4.1 游戏开发中的随机数：速度与质量的平衡

游戏开发对随机数的需求比较特殊。一方面，游戏里到处都要用随机数，比如掉落概率、暴击判定、敌人行为、地图生成，调用非常频繁；另一方面，玩家对随机性的感知很敏感，如果随机数质量太差，玩家会发现规律，影响体验。

对于大多数游戏逻辑，std::mt19937是够用的。它的速度不错，质量也高。但如果是在性能敏感的循环里，比如每帧要生成几千个随机数，可以考虑用std::minstd_rand或者自己实现一个轻量级的引擎。不过说实话，现代 CPU 上std::mt19937的速度已经很快了，除非是极端情况，否则没必要为了速度牺牲质量。

游戏里还有一个常见需求是可重现的随机序列。比如 Roguelike 游戏，同一个种子应该生成同一个地图。这时候就需要把种子保存下来，用固定的种子初始化引擎。std::mt19937支持通过seed()方法重新设置种子，也支持序列化和反序列化，方便存档。

#include <random> #include <iostream> class GameRandom { private: std::mt19937 gen; public: GameRandom(uint32_t seed) : gen(seed) {} int roll(int min, int max) { std::uniform_int_distribution<int> dist(min, max); return dist(gen); } double chance() { std::uniform_real_distribution<double> dist(0.0, 1.0); return dist(gen); } uint32_t getSeed() const { return gen(); } }; int main() { GameRandom rng(12345); for (int i = 0; i < 5; ++i) { std::cout << rng.roll(1, 100) << " "; } std::cout << std::endl; return 0; }

这个类封装了引擎和常用分布，用起来很方便。注意getSeed()返回的是引擎当前状态的一个值，不是初始种子。如果要保存初始种子，需要另外存。

4.2 模拟与蒙特卡洛：为什么 mt19937 是首选

蒙特卡洛模拟需要大量高质量的随机数，对均匀性和独立性要求很高。std::mt19937是这方面的首选，它的周期长达 2^19937-1，在可预见的计算量下不会重复。它的均匀性也经过了严格的统计检验，适合科学计算。

在蒙特卡洛模拟中，通常需要生成[0, 1)之间的浮点随机数。用std::uniform_real_distribution<double>配合std::mt19937就可以。如果需要多维随机数，比如生成二维平面上的随机点，可以分别生成两个独立的随机数，或者用std::mt19937_64生成一个 64 位数然后拆成两个 32 位。

#include <random> #include <iostream> #include <cmath> int main() { std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution<double> dist(0.0, 1.0); int inside = 0; int total = 1000000; for (int i = 0; i < total; ++i) { double x = dist(gen); double y = dist(gen); if (x * x + y * y <= 1.0) { ++inside; } } double pi = 4.0 * inside / total; std::cout << "Estimated pi: " << pi << std::endl; return 0; }

这段代码用蒙特卡洛方法估算圆周率。一百万个样本，结果通常在 3.14 左右，误差在千分之一量级。如果换成rand()，由于精度和均匀性问题，误差会更大。

4.3 生成不重复随机序列的两种思路

有时候需要生成一组不重复的随机数，比如抽奖、洗牌、随机抽样。有两种常见思路：一种是生成随机数然后去重，另一种是先生成有序序列然后打乱。

去重法的思路是：用一个集合记录已经生成的数，每次生成新数时检查是否已存在，如果存在就重新生成。这种方法在需要的数量远小于范围时效率很高，但如果需要的数量接近范围大小，就会频繁碰撞，效率急剧下降。

洗牌法的思路是：先生成一个包含所有可能值的序列，然后用std::shuffle打乱。这种方法在需要大量不重复随机数时更高效，而且保证不会重复。

#include <random> #include <vector> #include <algorithm> #include <iostream> int main() { std::random_device rd; std::mt19937 gen(rd()); // 方法一：去重法 std::vector<int> unique_nums; std::uniform_int_distribution<int> dist(1, 100); while (unique_nums.size() < 10) { int num = dist(gen); if (std::find(unique_nums.begin(), unique_nums.end(), num) == unique_nums.end()) { unique_nums.push_back(num); } } // 方法二：洗牌法 std::vector<int> all_nums(100); std::iota(all_nums.begin(), all_nums.end(), 1); std::shuffle(all_nums.begin(), all_nums.end(), gen); std::vector<int> shuffled_nums(all_nums.begin(), all_nums.begin() + 10); std::cout << "Unique: "; for (int n : unique_nums) std::cout << n << " "; std::cout << "\nShuffled: "; for (int n : shuffled_nums) std::cout << n << " "; std::cout << std::endl; return 0; }

std::shuffle是 C++11 引入的，它需要一个随机数引擎作为参数。注意不要用std::random_shuffle，它在 C++14 被弃用，C++17 被移除，因为它内部用的是rand()，质量不高。

4.4 密码学安全随机数的边界

<random>库的随机数不适合密码学用途。std::mt19937是可预测的，只要知道足够多的输出，就能推算出内部状态，从而预测后续输出。std::random_device虽然可能提供不确定的值，但标准没有要求它必须是密码学安全的。

如果你需要密码学安全的随机数，比如生成密钥、令牌、盐值，应该使用专门的密码学库。在 C++ 里，常见的选择有 OpenSSL 的RAND_bytes、libsodium 的randombytes_buf，或者操作系统提供的接口。这些库的随机数生成器经过了密码学审查，能抵抗预测攻击。

不过，对于大多数非密码学场景，比如游戏、模拟、测试数据，<random>库完全够用。不要因为追求“安全”而引入不必要的依赖。

5. 那些年我踩过的随机数坑

随机数看起来简单，但实际用起来坑不少。这一节我把自己和身边同事踩过的坑整理出来，有些是理解偏差，有些是平台差异，有些是使用习惯问题。你可以对照看看有没有类似的经历。

5.1 跨平台差异：RAND_MAX 不是固定的

RAND_MAX的值在不同平台上可能不同。在 Windows 的 MSVC 上，RAND_MAX是 32767；在 Linux 的 glibc 上，RAND_MAX是 2147483647。这意味着同样的rand() % 100，在 Windows 和 Linux 上的偏差程度完全不同。在 Linux 上，因为RAND_MAX很大，偏差几乎可以忽略；在 Windows 上，偏差就明显一些。

更麻烦的是，如果你写了一个依赖RAND_MAX的算法，比如rand() / (double)RAND_MAX，在不同平台上的结果范围会不同。在 Windows 上，结果范围是[0, 1]，步长是 1/32767；在 Linux 上，结果范围也是[0, 1]，但步长是 1/2147483647。虽然范围一样，但精度差了很多。

所以，如果你的代码需要跨平台，最好不要依赖RAND_MAX的具体值。用<random>库可以避免这个问题，因为分布器会自动处理范围。

5.2 种子重复导致的“伪随机”事故

前面提过time(nullptr)的秒级精度问题，这里再展开说一下。我遇到过一次比较严重的事故：一个服务在启动时会用srand(time(nullptr))初始化随机种子，然后生成一个会话 ID。结果在压力测试的时候，多个实例在同一秒内启动，生成的会话 ID 大量重复，导致用户会话混乱。

后来改成用std::random_device加进程 ID 和线程 ID 混合做种子，问题才解决。这个教训是：不要假设time(nullptr)足够唯一。在高并发或者快速启动的场景下，秒级精度远远不够。

如果你非要用时间做种子，至少用高精度时钟，比如std::chrono::high_resolution_clock，它的精度通常是纳秒级。但即使这样，也不能保证唯一，因为两个线程可能在同一纳秒拿到相同的时间。更可靠的做法是用std::random_device，或者结合多个熵源。

5.3 分布器对象复用的性能陷阱

std::uniform_int_distribution的对象可以复用，但每次调用operator()都会重新计算一些内部状态。如果在循环里反复创建分布器对象，会有不必要的开销。正确的做法是把分布器对象放在循环外面，只创建一次。

// 不好的写法：每次循环都创建分布器 for (int i = 0; i < 1000000; ++i) { std::uniform_int_distribution<int> dist(1, 100); int x = dist(gen); } // 好的写法：分布器只创建一次 std::uniform_int_distribution<int> dist(1, 100); for (int i = 0; i < 1000000; ++i) { int x = dist(gen); }

这个差异在百万次循环里可能只有几毫秒，但在性能敏感的场景里值得注意。另外，分布器的operator()不是 const 的，因为它可能修改内部状态（比如拒绝采样时的缓存），所以不能把分布器声明为 const。

5.4 引擎状态保存与恢复的注意事项

std::mt19937支持通过operator<<和operator>>序列化和反序列化。这在需要保存随机状态的场景很有用，比如游戏存档、断点续跑。

#include <random> #include <sstream> #include <iostream> int main() { std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<int> dist(1, 100); // 生成一些随机数 for (int i = 0; i < 5; ++i) { std::cout << dist(gen) << " "; } std::cout << std::endl; // 保存状态 std::stringstream ss; ss << gen; // 继续生成 for (int i = 0; i < 5; ++i) { std::cout << dist(gen) << " "; } std::cout << std::endl; // 恢复状态 ss >> gen; // 再次生成，应该和恢复前一致 for (int i = 0; i < 5; ++i) { std::cout << dist(gen) << " "; } std::cout << std::endl; return 0; }

注意序列化的是引擎的状态，不是分布器的状态。分布器通常是无状态的（或者状态很少），所以一般不需要保存。但如果你用的是有状态的分布器，比如某些自适应分布，可能需要额外处理。

还有一个细节：不同标准库实现的序列化格式可能不同。如果你把状态保存到文件，然后在另一个平台上读取，可能会失败。所以跨平台存档的时候要小心，最好用自定义的格式，或者只保存初始种子。

5.5 随机数质量的自检方法

如果你不确定自己用的随机数质量如何，可以做一些简单的统计检验。比如生成大量随机数，看看分布是否均匀，均值是否接近期望，方差是否合理。

#include <random> #include <iostream> #include <vector> #include <cmath> int main() { std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<int> dist(1, 6); std::vector<int> counts(7, 0); int total = 600000; for (int i = 0; i < total; ++i) { counts[dist(gen)]++; } double expected = total / 6.0; double chi_square = 0.0; for (int i = 1; i <= 6; ++i) { double diff = counts[i] - expected; chi_square += diff * diff / expected; } std::cout << "Chi-square: " << chi_square << std::endl; // 自由度 5，95% 置信区间的临界值约为 11.07 // 如果 chi_square 小于 11.07，说明分布均匀性没有明显问题 return 0; }

这个卡方检验可以快速判断随机数是否均匀。如果卡方值远大于临界值，说明分布有问题。当然，这只是最基础的检验，更严格的检验需要专门的统计软件。

6. 从 rand 迁移到 random 的实操建议

如果你手头有老代码用的是rand()，想迁移到<random>，这一节给你一些实操建议。迁移不是简单的替换，因为两者的语义有差异，需要小心处理。

6.1 识别需要迁移的代码模式

首先，找出所有使用rand()和srand()的地方。常见的模式有：

• rand() % n：生成 0 到 n-1 的随机数
• rand() % n + m：生成 m 到 m+n-1 的随机数
• rand() / (double)RAND_MAX：生成 0 到 1 的浮点数
• srand(time(nullptr))：初始化种子

这些模式在迁移时都需要调整。rand() % n应该换成std::uniform_int_distribution<int>(0, n-1)，rand() % n + m换成std::uniform_int_distribution<int>(m, m+n-1)，rand() / (double)RAND_MAX换成std::uniform_real_distribution<double>(0.0, 1.0)。

6.2 逐步替换而不是一次性重写

迁移的时候不要一次性把所有rand()都替换掉，而是逐步来。可以先在一个模块里替换，测试通过后再推广到其他模块。这样可以控制风险，也方便定位问题。

替换的时候要注意，rand()和<random>产生的序列不同，所以如果代码依赖特定的随机序列（比如测试用例里硬编码了期望输出），迁移后测试可能会失败。这时候需要更新测试用例，或者用固定的种子来保证可重现性。

6.3 保持可重现性的种子管理

如果你的代码需要可重现的随机序列，比如在测试或者调试时，迁移后要确保种子管理一致。<random>的引擎可以用固定的种子初始化，产生固定的序列。但要注意，不同的标准库实现可能产生不同的序列，所以跨平台的可重现性不能保证。

如果需要跨平台可重现，可以考虑自己实现一个简单的引擎，或者用第三方的随机数库。但对于大多数应用，同平台可重现就足够了。

#include <random> #include <iostream> int main() { // 固定种子，保证可重现 std::mt19937 gen(42); std::uniform_int_distribution<int> dist(1, 100); for (int i = 0; i < 10; ++i) { std::cout << dist(gen) << " "; } std::cout << std::endl; return 0; }

这段代码每次运行都产生相同的序列，适合测试和调试。注意种子 42 是随便选的，你可以用任何值。

6.4 迁移后的性能对比与验证

迁移完成后，最好做一下性能对比。<random>的引擎通常比rand()慢一些，但分布器的开销可能更大。在性能敏感的场景，需要实测确认。

我做过一个简单的对比：生成一亿个 0 到 99 的随机整数，rand() % 100大约需要 0.3 秒，std::mt19937加std::uniform_int_distribution大约需要 0.8 秒。差距确实存在，但对于大多数应用来说，这个差距可以接受。如果性能是瓶颈，可以考虑用std::minstd_rand或者优化分布器的使用方式。

验证的时候还要检查随机数的质量。可以用前面提到的卡方检验，或者更严格的统计测试。确保迁移后的随机数质量没有下降。

6.5 封装一个易用的随机数工具类

最后，为了方便使用，可以封装一个随机数工具类，把引擎和常用分布封装起来。这样代码更简洁，也更容易维护。

#include <random> #include <cstdint> class Random { private: std::mt19937 gen; public: Random() : gen(std::random_device{}()) {} explicit Random(uint32_t seed) : gen(seed) {} int nextInt(int min, int max) { return std::uniform_int_distribution<int>(min, max)(gen); } double nextDouble(double min, double max) { return std::uniform_real_distribution<double>(min, max)(gen); } bool nextBool(double probability = 0.5) { return std::bernoulli_distribution(probability)(gen); } template<typename T> void shuffle(std::vector<T>& vec) { std::shuffle(vec.begin(), vec.end(), gen); } std::mt19937& engine() { return gen; } };

这个类提供了常用的随机数接口，用起来很方便。注意nextInt和nextDouble每次调用都创建分布器对象，这在性能敏感的场景可能不够高效。如果需要优化，可以把分布器对象缓存起来，但要注意分布器的状态问题。

实际用的时候，我一般会把这个类放在一个头文件里，然后在需要的地方包含。这样既方便，又不会引入太多依赖。如果你有更复杂的需求，比如正态分布、指数分布，可以继续扩展这个类。

随机数这个主题看起来简单，但真正用好需要理解背后的原理和陷阱。从rand()到<random>，C++ 提供了越来越好的工具，但工具越好，越需要知道怎么用。希望这些经验能帮你少踩几个坑。