C++ 使用随机数在C++；

我有一个存储随机数的无符号整数。我需要使用这个数字来生成一系列“类似随机数”的数字，如果这个原始随机数再次出现，它会生成完全相同的数字

i、 e

随机数：123456789

第一个“类随机数”：3

第二个“类随机数”：7

第三个“类随机数”：1

第四个“类随机数”：9

等等

下次随机数出现时，需要从中生成完全相同的数

非随机数可以被复制和/或环绕（如果使用的任何算法都没有数字，可以从头开始重新开始）。只要每次都生成相同的数字

我意识到这正是rand（）所做的（使用随机数播种），但我不能使用rand。因此，也许一个更简洁的问题是，我如何复制一个“迷你”兰德函数（它不需要任何复杂的东西，只要出来的数字看起来有点随机）

我也不能使用boost（很遗憾）

---

任何指针/提示？

将实现线性同余生成器的类组合在一起：

您可以查找A和C的良好值，并使用2^32作为M（模数） 数字配方示例：A=1664525，C=1013904223

如文章所述，使用2^32作为模数在32位字大小上是“自由”的

这与大多数版本的rand（）使用的算法相同

请注意，它是不安全的

---

种子值为x。使用相同的种子将生成相同的序列。

组合一个实现线性同余生成器的类：

您可以查找A和C的良好值，并使用2^32作为M（模数） 数字配方示例：A=1664525，C=1013904223

如文章所述，使用2^32作为模数在32位字大小上是“自由”的

这与大多数版本的rand（）使用的算法相同

请注意，它是不安全的

种子值为x。使用相同的种子将生成相同的序列。

我不知道为什么不能使用

rand

本身，但如果不能，则可以自己滚动。使用整数为一个数字设定种子，然后使用标准的

Xn+1=a*Xn+c mod m

对于

a

、

c

和

m

，具有一些示例值

现在LCM并不是世界上最大的随机数生成器，但是，如果你只想要“看起来有点随机”的数字，它应该足够了

作为LCM算法的一个示例，以下函数基于上面链接页面中的

Microsoft Visual/Quick C/C++

条目：

// LCM pseudo-random number generator.
// Outputs numbers from 0..32767 inclusive.
// With protection against identical sequences.
//   due to full 32-bit cycle but only returning 15 bits.

uint32_t myRand (void) {
    const static uint32_t a = 214013U;
    const static uint32_t c = 2531011U;
    // m is, of course, 2^32 since the values will wrap.

    static uint32_t seed = 1;
    seed = seed * a + c;
    return (seed >> 16) & 0x7FFF;
}

循环时间为32位数字的整个范围，但每次仅返回种子的某些位，这减少了相同序列的出现

如果你想要一个C++类来实现这一点，这样所有的随机数生成器都是相互独立的（如ToMZ所建议的），你可以使用类似的：

class myRand {
    public:
        myRand ();
        myRand (unsigned int newSeed);
        ~myRand ();
        void setSeed (unsigned int newSeed);
        unsigned int getSeed (void);
        unsigned int next (void);
    private:
        unsigned int seed;
        const static unsigned int a = 214013U;
        const static unsigned int c = 2531011U;
};

myRand::myRand () { seed = 1; }
myRand::myRand (unsigned int newSeed) { setSeed (newSeed); }
myRand::~myRand () { }
void myRand::setSeed (unsigned int newSeed) { seed = newSeed; }
unsigned int myRand::getSeed (void) { return seed; }
unsigned int myRand::next (void) {
    seed = (seed * a + c) & 0xffffffff;
    return (seed >> 16) & 0x7fff;
}

#包括
内部主（空）{
迈兰德r（5）；
std:：cout我不知道为什么不能使用
rand
本身，但是，如果不能，那么你可以自己滚动。使用整数作为数字种子，然后使用标准的
Xn+1=a*Xn+c mod m

对于
a
、
c
和
m
，具有一些示例值

现在LCM并不是世界上最大的随机数生成器，但是，如果你只想要“看起来有点随机”的数字，它应该足够了

作为LCM算法的一个示例，以下函数基于上面链接页面中的
Microsoft Visual/Quick C/C++
条目：

// LCM pseudo-random number generator.
// Outputs numbers from 0..32767 inclusive.
// With protection against identical sequences.
//   due to full 32-bit cycle but only returning 15 bits.

uint32_t myRand (void) {
    const static uint32_t a = 214013U;
    const static uint32_t c = 2531011U;
    // m is, of course, 2^32 since the values will wrap.

    static uint32_t seed = 1;
    seed = seed * a + c;
    return (seed >> 16) & 0x7FFF;
}

循环时间为32位数字的整个范围，但每次仅返回种子的某些位，这减少了相同序列的出现

如果你想要一个C++类来实现这一点，这样所有的随机数生成器都是相互独立的（如ToMZ所建议的），你可以使用类似的：
class myRand {
    public:
        myRand ();
        myRand (unsigned int newSeed);
        ~myRand ();
        void setSeed (unsigned int newSeed);
        unsigned int getSeed (void);
        unsigned int next (void);
    private:
        unsigned int seed;
        const static unsigned int a = 214013U;
        const static unsigned int c = 2531011U;
};

myRand::myRand () { seed = 1; }
myRand::myRand (unsigned int newSeed) { setSeed (newSeed); }
myRand::~myRand () { }
void myRand::setSeed (unsigned int newSeed) { seed = newSeed; }
unsigned int myRand::getSeed (void) { return seed; }
unsigned int myRand::next (void) {
    seed = (seed * a + c) & 0xffffffff;
    return (seed >> 16) & 0x7fff;
}


#包括
内部主（空）{
迈兰德r（5）；
std：：cout您可以从
（或
）中选择任何伪随机数生成引擎，并使用它为统一的整数分布提供燃料

只要使用相同的数字对引擎进行种子设定，得到的整数序列就会相同

例如：

#include <random>

std::mt19937 rng;  // everyone's favourite engine: fast, long period
std::uniform_int_distribution<uint32_t> uniformUINT32(0, 99);  // numbers in the range [0, 100)

int main()
{
  static const unsigned long int seed = 123;
  rng.seed(seed);

  int val;
  val = uniformUINT32(rng);  // a predictable random number (69)
  val = uniformUINT32(rng);  // ditto (71)
}

#包括
std:：mt19937 rng；//每个人最喜欢的引擎：快速、长周期
std:：uniform_int_distribution uniformormuint32（0，99）；//范围[0，100]内的数字
int main（）
{
静态常量无符号长整数种子=123；
种子（种子）；
int-val；
val=uniformUINT32（rng）；//一个可预测的随机数（69）
val=uniformUINT32（rng）；//同上（71）
}
您可以从
（或
）中选择任何伪随机数生成引擎，并使用它为均匀整数分布提供燃料

只要使用相同的数字对引擎进行种子设定，得到的整数序列就会相同

例如：

#include <random>

std::mt19937 rng;  // everyone's favourite engine: fast, long period
std::uniform_int_distribution<uint32_t> uniformUINT32(0, 99);  // numbers in the range [0, 100)

int main()
{
  static const unsigned long int seed = 123;
  rng.seed(seed);

  int val;
  val = uniformUINT32(rng);  // a predictable random number (69)
  val = uniformUINT32(rng);  // ditto (71)
}

#包括
std:：mt19937 rng；//每个人最喜欢的引擎：快速、长周期
std:：uniform_int_distribution uniformormuint32（0，99）；//范围[0，100]内的数字
int main（）
{
静态常量无符号长整数种子=123；
种子（种子）；
int-val；
val=uniformUINT32（rng）；//一个可预测的随机数（69）
val=uniformUINT32（rng）；//同上（71）
}
对于您的案例，您可以使用伪随机数生成器（适用于做一些快速有趣的事情，但不适用于安全/科学相关领域）

Rn的数据类型是uint32\t，用于支持类型环绕。Rn的初始值用作种子。
对于您的情况，您可以使用伪随机数生成器（适用于做一些快速有趣的事情，但不适用于安全/科学相关领域）

数据类型