推荐初始化srand的方法？

Question 1

我需要一种“好的”方式来初始化C ++中的伪随机数生成器。我发现一篇文章指出：

为了生成类似随机数的数字，通常将srand初始化为一些与众不同的值，例如与执行时间相关的值。例如，函数时间（在头文件ctime中声明）返回的值每秒都是不同的，对于大多数随机需求而言，这是足够独特的。

对于我的应用程序而言，Unixtime不够鲜明。有什么更好的初始化方法？如果它是可移植的，则有很多好处，但是代码将主要在Linux主机上运行。

我当时在考虑做一些pid / unixtime数学来获取整数，或者可能从中读取数据/dev/urandom。

谢谢！

编辑

是的，我实际上每秒多次启动我的应用程序，并且遇到了冲突。

Question 2

最好的答案是使用Boost随机数的东西。或者，如果您有权访问C ++ 11，请使用<random>标头。

但是，如果我们正在谈论rand()和srand()
最好的方法就是使用time()：

int main()
{
    srand(time(NULL));

    ...
}

确保在程序开始时执行此操作，而不是每次调用时都执行此操作rand()！

每次启动时，time（）都会返回一个唯一值（除非您每秒多次启动该应用程序）。在32位系统中，它将仅每60年左右重复一次。

我知道您认为时间不够独特，但我很难相信。但众所周知我错了。

如果同时启动许多应用程序副本，则可以使用分辨率更高的计时器。但是，这样一来，您可能会在较短的时间内重复输入该值。

好的，所以如果您真的认为自己正在启动多个应用程序。
然后在计时器上使用较细的颗粒。

 int main()
 {
     struct timeval time; 
     gettimeofday(&time,NULL);

     // microsecond has 1 000 000
     // Assuming you did not need quite that accuracy
     // Also do not assume the system clock has that accuracy.
     srand((time.tv_sec * 1000) + (time.tv_usec / 1000));

     // The trouble here is that the seed will repeat every
     // 24 days or so.

     // If you use 100 (rather than 1000) the seed repeats every 248 days.

     // Do not make the MISTAKE of using just the tv_usec
     // This will mean your seed repeats every second.
 }

Question 3

这是我用于可频繁运行（每秒多次）的小型命令行程序的方法：

unsigned long seed = mix(clock(), time(NULL), getpid());

混合在哪里：

// http://www.concentric.net/~Ttwang/tech/inthash.htm
unsigned long mix(unsigned long a, unsigned long b, unsigned long c)
{
    a=a-b;  a=a-c;  a=a^(c >> 13);
    b=b-c;  b=b-a;  b=b^(a << 8);
    c=c-a;  c=c-b;  c=c^(b >> 13);
    a=a-b;  a=a-c;  a=a^(c >> 12);
    b=b-c;  b=b-a;  b=b^(a << 16);
    c=c-a;  c=c-b;  c=c^(b >> 5);
    a=a-b;  a=a-c;  a=a^(c >> 3);
    b=b-c;  b=b-a;  b=b^(a << 10);
    c=c-a;  c=c-b;  c=c^(b >> 15);
    return c;
}

Question 4

如果您需要更好的随机数生成器，请不要使用libc rand。而是直接使用类似/dev/random或/dev/urandom直接的内容（int直接从中读取内容或类似的内容）。

libc rand的唯一真正好处是给定了种子，这是可预见的，有助于调试。

Question 5

在Windows上：

srand(GetTickCount());

提供的种子好time()于毫秒。

Question 6

C ++ 11 random_device

如果您需要合理的质量，那么首先不要使用rand（）。您应该使用该<random>库。它提供了许多出色的功能，例如用于不同质量/尺寸/性能折衷，重新进入和预定义分布的各种引擎，因此您最终不会出错。根据您的实现，它甚至可以轻松访问不确定的随机数据（例如/ dev / random）。

#include <random>
#include <iostream>

int main() {
    std::random_device r;
    std::seed_seq seed{r(), r(), r(), r(), r(), r(), r(), r()};
    std::mt19937 eng(seed);

    std::uniform_int_distribution<> dist{1,100};

    for (int i=0; i<50; ++i)
        std::cout << dist(eng) << '\n';
}

eng是随机性的来源，这里是梅森纳捻线器的内置实现。我们使用random_device对其进行播种，在任何体面的实现中，它将是非确定性的RNG，并使用seed_seq组合超过32位的随机数据。例如在libc ++中，random_device默认访问/ dev / urandom（尽管您可以给它另一个文件来访问）。

接下来，我们创建一个分布，以便在给定随机源的情况下，对该分布的重复调用将产生从1到100的整数均匀分布。然后，我们继续重复使用该分布并打印结果。

Question 7

最好的方法是使用另一个伪随机数生成器。我建议使用Mersenne捻线机（和Wichmann-Hill）。

http://en.wikipedia.org/wiki/梅森_twister

Question 8

我建议您在mozilla代码中看到unix_random.c文件。（猜它是mozilla / security / freebl / ...）应该在freebl库中。

那里它使用系统调用信息（例如pwd，netstat ....）为随机数生成噪声；它被编写为支持大多数平台（可以为我带来加分：D）。

Question 9

您必须问自己的真正问题是您需要什么随机性质量。

libc random是一个LCG

无论您提供什么投入，随机性的质量都会很低。

如果仅需要确保不同的实例具有不同的初始化，则可以混合使用进程ID（getpid），线程ID和计时器。将结果与xor混合。熵对于大多数应用来说应该足够了。

范例：

struct timeb tp;
ftime(&tp);   
srand(static_cast<unsigned int>(getpid()) ^ 
static_cast<unsigned int>(pthread_self()) ^ 
static_cast<unsigned int >(tp.millitm));

为了获得更好的随机质量，请使用/ dev / urandom。您可以使用boost :: thread和boost :: date_time使以上代码可移植。

Question 10

c++11乔纳森·赖特（Jonathan Wright）投票最多的帖子的版本：

#include <ctime>
#include <random>
#include <thread>

...

const auto time_seed = static_cast<size_t>(std::time(0));
const auto clock_seed = static_cast<size_t>(std::clock());
const size_t pid_seed =
      std::hash<std::thread::id>()(std::this_thread::get_id());

std::seed_seq seed_value { time_seed, clock_seed, pid_seed };

...
// E.g seeding an engine with the above seed.
std::mt19937 gen;
gen.seed(seed_value);

Question 11

#include <stdio.h>
#include <sys/time.h>
main()
{
     struct timeval tv;
     gettimeofday(&tv,NULL);
     printf("%d\n",  tv.tv_usec);
     return 0;
}

tv.tv_usec以微秒为单位。这应该是可以接受的种子。

Question 12

只要您的程序仅在Linux上运行（并且您的程序是ELF可执行文件），就可以确保内核为您的进程提供ELF aux向量中的唯一随机种子。内核为您提供16个随机字节，每个字节各不相同，您可以使用获得getauxval(AT_RANDOM)。要将它们用于srand，请仅使用int它们中的一个，例如：

#include <sys/auxv.h>

void initrand(void)
{
    unsigned int *seed;

    seed = (unsigned int *)getauxval(AT_RANDOM);
    srand(*seed);
}

这也有可能转换为其他基于ELF的系统。我不确定在Linux以外的系统上实现了哪些aux值。

Question 13

假设您有一个签名如下的函数：

int foo(char *p);

随机种子的最佳熵源是以下各项的哈希：

完整的结果clock_gettime（秒和纳秒）而不会丢掉低位-它们是最有价值的。
的值p，转换为uintptr_t。
的地址p，转换为uintptr_t。

如果有的话，至少第三个（也可能是第二个）从系统的ASLR导出熵（初始堆栈地址以及当前堆栈地址在某种程度上是随机的）。

为了避免触及全局状态，我也将避免完全使用rand/ srand，因此您可以更好地控制所使用的PRNG。但是，无论您使用什么PRNG，上述过程都是一种无需过多工作即可获得不错的熵的好方法（并且相当便于移植）。

Question 14

对于使用Visual Studio的用户，这是另一种方法：

#include "stdafx.h"
#include <time.h>
#include <windows.h> 

const __int64 DELTA_EPOCH_IN_MICROSECS= 11644473600000000;

struct timezone2 
{
  __int32  tz_minuteswest; /* minutes W of Greenwich */
  bool  tz_dsttime;     /* type of dst correction */
};

struct timeval2 {
__int32    tv_sec;         /* seconds */
__int32    tv_usec;        /* microseconds */
};

int gettimeofday(struct timeval2 *tv/*in*/, struct timezone2 *tz/*in*/)
{
  FILETIME ft;
  __int64 tmpres = 0;
  TIME_ZONE_INFORMATION tz_winapi;
  int rez = 0;

  ZeroMemory(&ft, sizeof(ft));
  ZeroMemory(&tz_winapi, sizeof(tz_winapi));

  GetSystemTimeAsFileTime(&ft);

  tmpres = ft.dwHighDateTime;
  tmpres <<= 32;
  tmpres |= ft.dwLowDateTime;

  /*converting file time to unix epoch*/
  tmpres /= 10;  /*convert into microseconds*/
  tmpres -= DELTA_EPOCH_IN_MICROSECS; 
  tv->tv_sec = (__int32)(tmpres * 0.000001);
  tv->tv_usec = (tmpres % 1000000);


  //_tzset(),don't work properly, so we use GetTimeZoneInformation
  rez = GetTimeZoneInformation(&tz_winapi);
  tz->tz_dsttime = (rez == 2) ? true : false;
  tz->tz_minuteswest = tz_winapi.Bias + ((rez == 2) ? tz_winapi.DaylightBias : 0);

  return 0;
}


int main(int argc, char** argv) {

  struct timeval2 tv;
  struct timezone2 tz;

  ZeroMemory(&tv, sizeof(tv));
  ZeroMemory(&tz, sizeof(tz));

  gettimeofday(&tv, &tz);

  unsigned long seed = tv.tv_sec ^ (tv.tv_usec << 12);

  srand(seed);

}

也许有点过分，但在快速间隔内效果很好。gettimeofday函数在这里找到。

编辑：经过进一步调查，rand_s可能是Visual Studio的一个很好的选择，它不仅是安全的rand（），而且完全不同，并且不使用srand的种子。我以为它和兰德几乎一样，只是“更安全”。

要使用rand_s，请不要忘记在包含stdlib.h之前#define _CRT_RAND_S。

Question 15

假设srand（）+ rand（）的随机性足以满足您的目的，诀窍是为srand选择最佳种子。time（NULL）是一个很好的起点，但是如果在同一秒内启动多个程序实例，则会遇到问题。添加pid（进程ID）是一项改进，因为不同的实例将获得不同的pid。我会将pid乘以一个因子，以将其扩展更多。

但是，假设您将其用于某些嵌入式设备，并且在同一网络中有多个设备。如果它们都立即通电，并且您在引导时自动启动程序的多个实例，则它们可能仍会获得相同的时间和pid，并且所有设备将生成相同的“随机”数字序列。在这种情况下，您可能需要为每个设备添加一些唯一标识符（例如CPU序列号）。

建议的初始化将是：

srand(time(NULL) + 1000 * getpid() + (uint) getCpuSerialNumber());

在Linux机器上（至少在我测试过的Raspberry Pi中），可以实现以下功能来获取CPU序列号：

// Gets the CPU Serial Number as a 64 bit unsigned int. Returns 0 if not found.
uint64_t getCpuSerialNumber() {

    FILE *f = fopen("/proc/cpuinfo", "r");
    if (!f) {
        return 0;
    }

    char line[256];
    uint64_t serial = 0;
    while (fgets(line, 256, f)) {
        if (strncmp(line, "Serial", 6) == 0) {
            serial = strtoull(strchr(line, ':') + 2, NULL, 16);
        }
    }
    fclose(f);

    return serial;
}

Question 16

在程序顶部包含标头，然后编写：

srand(time(NULL));

在程序中声明随机数之前。这是一个程序的示例，该程序输出一个介于1到10之间的随机数：

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
   //Initialize srand
   srand(time(NULL));

   //Create random number
   int n = rand() % 10 + 1;

   //Print the number
   cout << n << endl; //End the line

   //The main function is an int, so it must return a value
   return 0;
}