c++11伪随机数生成库：random

随机数引擎

linear_congruential_engine 实现线性同余算法 mersenne_twister_engine 实现梅森缠绕器算法 subtract_with_carry_engine 实现带进位减（一种延迟斐波那契）算法 以上三个引擎都是类模板，它们第一个模板参数都是UIntType，表示生成数字的类型，且在内部被定义为result_type成员类型，其他模板参数是特定算法需要的参数。 它们的构造函数类似，以linear_congruential_engine为例说明：

linear_congruential_engine() : linear_congruential_engine(default_seed) {} (1) explicit linear_congruential_engine(result_type value); (2) template <class Sseq> explicit linear_congruential_engine(Sseq& s); (3) linear_congruential_engine(const linear_congruential_engine&); (4)(隐式声明) 构造引擎并初始化状态。 (1)默认构造函数。以 default_seed 播种引擎。 仅若 Sseq 符合种子序列要求，(3)才参与重载决议。尤其是若 Sseq 可转换为 result_type，则从候选函数集中排除该重载。

类 std::seed_seq 满足种子序列的要求。一个 seed_seq 对象消耗整数值数列，并基于消耗的数据生成请求数量的无符号整数值 i，0<=i < 2^32。产生的值分布在整个 32 位范围上，即使消耗的值接近。seed_seq 的构造函数和 generate 函数声明如下：

seed_seq(); seed_seq(const seed_seq&) = delete; template <class InputIt> seed_seq(InputIt begin, InputIt end); template <class T> seed_seq(std::initializer_list<T> il); template <class RandomIt> void generate(RandomIt begin, RandomIt end);

一个简单的例子：

#include <random> #include <cstdint> #include <iostream> int main() { std::seed_seq seq{1,2,3,4,5}; std::vector<std::uint32_t> seeds(10); seq.generate(seeds.begin(), seeds.end()); for (std::uint32_t n : seeds) { std::cout << n << '\n'; } return 0; }

回到三个随机数引擎上，它们还有一些公共的成员函数：

void seed(result_type value = default_seed); template <class Sseq> void seed(Sseq& seq); 用新种子值重新初始化随机数引擎的内部状态。 result_type operator()(); 生成伪随机数。令引擎状态前进一个位置。 void discard(unsigned long long z); 令内部状态前进 z 次。等价于调用 operator() z 次并舍弃结果。 static constexpr result_type min(); 返回随机数引擎潜在生成的最小值。此值等于 0u 。 static constexpr result_type max(); 返回随机数引擎潜在生成的最大值。

此外还有以下非成员函数：

operator== operator!= 比较两个伪随机数引擎的内部状态 operator<< operator>> 执行伪随机数引擎的流输入和输出 前者序列化引擎的内部状态为一或多个空格分隔的十进制数序列，并插入到流。后者能将十进制数序列还原为原引擎。

随机数引擎适配器

template <class Engine, size_t P, size_t R> class discard_block_engine; discard_block_engine 忽略基础引擎所产生的一定量数据。 生成器只从基础引擎生成的每个 P 大小的块保留 R 个数，舍弃剩余的数。 P - 块大小。必须大于 0 。 R - 每块用的数字数。必须大于 0 且不大于 P 。 template <class Engine, std::size_t W, class UIntType> class independent_bits_engine; class independent_bits_engine 将一个随机数引擎的输出适配为具有特定比特数的数字。 W - 生成数字应有的比特数，其他位填0。必须大于零，且不大于 std::numeric_limits<UIntType>::digits。 UIntType - 生成的随机数类型。类型必须是无符号整数类型。 std::independent_bits_engine<default_random_engine, 4, unsigned> e; std::cout << '[' << e.min() << ", " << e.max() << ']' << std::endl; //输出结果是[0, 15] template <class Engine, std::size_t K> class shuffle_order_engine; shuffle_order_engine 打乱基础引擎生成的随机数。 它维护一个大小为 K 的表，并在请求时随机地从该表派送被选择数，将它替换为基础引擎生成的数。

非确定随机数

std::random_device 是生成非确定随机数的均匀分布整数随机数生成器。 std::random_device 可以以实现定义的伪随机数引擎实现，在某些实现中可能每个 std::random_device 对象生成同一数值序列。 std::random_device 一般作为其他随机数引擎的种子使用。

random_device() : random_device(/*implementation-defined*/) {} explicit random_device(const std::string& token); 标准期待 token 指定产生随机数字的字节设备，比如 linux 下的 /dev/random 。 random_device(const random_device& ) = delete; random_device& operator=(const random_device&) = delete; result_type operator()(); 生成均匀分布的非确定随机值。 static constexpr result_type min(); 返回随机数引擎潜在生成的最小值。此值等于 0u 。 static constexpr result_type max(); 返回随机数引擎潜在生成的最大值。此值等于 std::numeric_limits<unsigned int>::max() 。

简单例子：

#include <iostream> #include <random> int main() { std::uniform_int_distribution<int> d(0, 10); std::random_device rd1; // 使用 RDRND 或 /dev/urandom for(int n = 0; n < 10; ++n) std::cout << d(rd1) << ' '; std::cout << '\n'; std::random_device rd2("/dev/random"); // Linux 上更慢 for(int n = 0; n < 10; ++n) std::cout << d(rd2) << ' '; std::cout << '\n'; }

预定义生成器

minstd_rand0 std::linear_congruential_engine<std::uint_fast32_t, 16807, 0, 2147483647> 由 Lewis、Goodman 及 Miller 发现于 1969，由 Park 与 Miller 于 1988 采纳为“最小标准” minstd_rand std::linear_congruential_engine<std::uint_fast32_t, 48271, 0, 2147483647> 较新的“最小标准”，为 Park、 Miller 及 Stockmeyer 于 1993 推荐 mt19937 std::mersenne_twister_engine<std::uint_fast32_t, ... 32 位梅森缠绕器，由松本与西村发现于 1998 mt19937_64 std::mersenne_twister_engine<std::uint_fast64_t, ... 64 位梅森缠绕器，由松本与西村设计于 2000 ranlux24_base std::subtract_with_carry_engine<std::uint_fast32_t, 24, 10, 24> ranlux48_base std::subtract_with_carry_engine<std::uint_fast64_t, 48, 5, 12> ranlux24 std::discard_block_engine<std::ranlux24_base, 223, 23> 24 位 RANLUX 生成器，由 Martin Lüscher 与 Fred James 设计于 1994 ranlux48 std::discard_block_engine<std::ranlux48_base, 389, 11> 48 位 RANLUX 生成器，由 Martin Lüscher 与 Fred James 设计于 1994 knuth_b std::shuffle_order_engine<std::minstd_rand0, 256> default_random_engine 实现定义

一般来说像下面这样用：

#include <random> #include <iostream> int main() { std::random_device rd; std::default_random_engine gen(rd()); for(int i=0; i<10; ++i) std::cout << gen() << ' '; return 0; }

用于产生满足特定分布数字的类/类模板/函数模板

generate_canonical

template <class RealType, size_t bits, class Generator> RealType generate_canonical(Generator& g); 生成范围 [0, 1) 中的随机浮点值。 RealType - 浮点类型。 bits - 精度，如果该值大于RealType的精度，将使用 numeric_limits<RealType>::digits 。

简单例子：

#include <random> #include <iostream> int main() { std::random_device rd; std::mt19937 gen(rd()); for(int n = 0; n < 10; ++n) { std::cout << std::generate_canonical<double, 10>(gen) << ' '; } }

均匀分布

uniform_int_distribution 产生在一个范围上均匀分布的整数值。(类模板) uniform_real_distribution 产生在一个范围上均匀分布的实数值。(类模板)

伯努利分布

bernoulli_distribution 产生伯努利分布上的 bool 值。(类) binomial_distribution 产生二项分布上的整数值。(类模板) negative_binomial_distribution 产生负二项分布上的整数值。(类模板) geometric_distribution 产生几何分布上的整数值。(类模板)

泊松分布

poisson_distribution 产生泊松分布上的整数值。(类模板) exponential_distribution 产生指数分布上的实数值。(类模板) gamma_distribution 产生 Γ 分布上的实数值(类模板) weibull_distribution 产生威布尔分布上的实数值。(类模板) extreme_value_distribution 产生极值分布上的实数值。(类模板)

正态分布

normal_distribution 产生标准正态（高斯）分布上的实数值。(类模板) lognormal_distribution 产生对数正态分布上的实数值。(类模板) chi_squared_distribution 产生 χ2 分布上上的实数值。(类模板) cauchy_distribution 产生柯西分布上的实数值。(类模板) fisher_f_distribution 产生费舍尔 F 分布上的实数值。(类模板) student_t_distribution 产生学生 t 分布上的实数值。(类模板)

采样分布

discrete_distribution 产生离散分布上的随机整数。(类模板) piecewise_constant_distribution 产生分布在常子区间上的实数值。(类模板) piecewise_linear_distribution 产生分布在定义的子区间上的实数值。(类模板)

以上的类或类模板使用方式都是类似的，构造函数根据参数生成概率分布函数，使用operator()()根据关联的概率分布函数生成随机数。 他们主要有以下常用成员：

成员类型result_type，operator()()的返回值。 void reset(); 重置分布对象的内部状态 template <class Generator> result_type operator()(Generator& g); 根据关联的概率分布函数生成随机数。由调用 g.operator() 获得熵。 result_type min() const; 返回分布潜在生成的最小值。 result_type max() const; 返回分布潜在生成的最大值。

看一个正态分布的例子：

#include <iostream> #include <iomanip> #include <string> #include <map> #include <random> #include <cmath> int main() { std::random_device rd{}; std::mt19937 gen{rd()}; // 值最可能接近平均 // 标准差影响生成的值距离平均数的分散 std::normal_distribution<> d{5,2}; std::map<int, int> hist; for(int n=0; n<50000; ++n) { ++hist[std::round(d(gen))]; } for(auto &p : hist) { std::cout << std::setw(2) << p.first << ' ' << std::string(p.second/200, '*') << '\n'; } return 0; }

输出是：

-4 -3 -2 -1 0 ** 1 ******* 2 *************** 3 ****************************** 4 ******************************************* 5 ************************************************* 6 ******************************************* 7 ****************************** 8 **************** 9 ****** 10 ** 11 12 13 14

参考 cppreference.com cplusplus.com