C++中的srand(time(null))利用时间设置随机种子产生随机数

   首先需要声明的是，计算机不会产生绝对随机的随机数，计算机只能产生“伪随机数”。其实绝对随机的随机数只是一种理想的随机数，即使计算机怎样发展，它也不会产生一串绝对随机的随机数。计算机只能生成相对的随机数，即伪随机数。

   伪随机数并不是假随机数，这里的“伪”是有规律的意思，就是计算机产生的伪随机数既是随机的又是有规律的。怎样理解呢？产生的伪随机数有时遵守一定的规律，有时不遵守任何规律；伪随机数有一部分遵守一定的规律；另一部分不遵守任何规律。比如“世上没有两片形状完全相同的树叶”，这正是点到了事物的特性，即随机性，但是每种树的叶子都有近似的形状，这正是事物的共性，即规律性。从这个角度讲，你大概就会接受这样的事实了：计算机只能产生伪随机数而不能产生绝对随机的随机数。

   那么计算机中随机数是怎样产生的呢？有人可能会说，随机数是由“随机种子”产生的。没错，随机种子是用来产生随机数的一个数，在计算机中，这样的一个“随机种子”是一个无符号整形数。那么随机种子是从哪里获得的呢？

   下面看这样一个C程序：

[cpp]  view plain  copy

1.   

//rand01.c #include <dos.h> #include <stdio.h> #include <mem.h> static unsigned int RAND_SEED;

unsigned int random(void) {  RAND_SEED=(RAND_SEED*123+59)%65536;  return(RAND_SEED); }

void random_start(void) {  int temp[2];  movedata(0x0040,0x006c,FP_SEG(temp),FP_OFF(temp),4);  RAND_SEED=temp[0]; }

main() {  unsigned int i,n;  random_start();  for(i=0;i<10;i++)   printf("%u/t",random());  printf("/n"); }

这个程序（rand01.c）完整地阐述了随机数产生的过程： 
首先，主程序调用random_start()方法，random_start()方法中的这一句我很感兴趣： 

movedata(0x0040,0x006c,FP_SEG(temp),FP_OFF(temp),4); 

这个函数用来移动内存数据，其中FP_SEG（far pointer to segment）是取temp数组段地址的函数，FP_OFF（far pointer to offset）是取temp数组相对地址的函数，movedata函数的作用是把位于0040:006CH存储单元中的双字放到数组temp的声明的两个存储单元中。这样可以通过temp数组把0040:006CH处的一个16位的数送给RAND_SEED。

random用来根据随机种子RAND_SEED的值计算得出随机数，其中这一句： 

RAND_SEED=(RAND_SEED*123+59)%65536; 

是用来计算随机数的方法，随机数的计算方法在不同的计算机中是不同的，即使在相同的计算机中安装的不同的操作系统中也是不同的。我在linux和windows下分别试过，相同的随机种子在这两种操作系统中生成的随机数是不同的，这说明它们的计算方法不同。

现在，我们明白随机种子是从哪儿获得的，而且知道随机数是怎样通过随机种子计算出来的了。那么，随机种子为什么要在内存的0040:006CH处取？0040:006CH处存放的是什么？

学过《计算机组成原理与接口技术》这门课的人可能会记得在编制ROM BIOS时钟中断服务程序时会用到Intel 8253定时/计数器，它与Intel 8259中断芯片的通信使得中断服务程序得以运转，主板每秒产生的18.2次中断正是处理器根据定时/记数器值控制中断芯片产生的。在我们计算机的主机板上都会有这样一个定时/记数器用来计算当前系统时间，每过一个时钟信号周期都会使记数器加一，而这个记数器的值存放在哪儿呢？没错，就在内存的0040:006CH处，其实这一段内存空间是这样定义的：

TIMER_LOW DW ? ；地址为 0040:006CH 
TIMER_HIGH DW ? ；地址为 0040:006EH 
TIMER_OFT DB ? ；地址为 0040:0070H 

时钟中断服务程序中，每当TIMER_LOW转满时，此时，记数器也会转满，记数器的值归零，即TIMER_LOW处的16位二进制归零，而TIMER_HIGH加一。rand01.c中的

movedata(0x0040,0x006c,FP_SEG(temp),FP_OFF(temp),4); 

正是把TIMER_LOW和TIMER_HIGH两个16位二进制数放进temp数组，再送往RAND_SEED，从而获得了“随机种子”。 

现在，可以确定的一点是，随机种子来自系统时钟，确切地说，是来自计算机主板上的定时/计数器在内存中的记数值。这样，我们总结一下前面的分析，并讨论一下这些结论在程序中的应用：

1.随机数是由随机种子根据一定的计算方法计算出来的数值。所以，只要计算方法一定，随机种子一定，那么产生的随机数就不会变。 

看下面这个C++程序：

[cpp]  view plain  copy

1. //rand02.cpp   
2. #include   
3. #include   
4. using namespace std;   
5.   
6. int main()   
7. {   
8. unsigned int seed=5;   
9. srand(seed);   
10. unsigned int r=rand();   
11. cout< // 编辑者注：可能代码有缺   
12. }   

 

在相同的平台环境下，编译生成exe后，每次运行它，显示的随机数都是一样的。这是因为在相同的编译平台环境下，由随机种子生成随机数的计算方法都是一样的，再加上随机种子一样，所以产生的随机数就是一样的。

2.只要用户或第三方不设置随机种子，那么在默认情况下随机种子来自系统时钟（即定时/计数器的值） 

看下面这个C++程序：

[cpp]  view plain  copy

1. //rand03.cpp   
2. #include   
3. #include   
4. using namespace std;   
5.   
6. int main()   
7. {   
8. srand((unsigned)time(NULL));   
9. unsigned int r=rand();   
10. cout< return 0;   
11. }   

这里用户和其他程序没有设定随机种子，则使用系统定时/计数器的值做为随机种子，所以，在相同的平台环境下，编译生成exe后，每次运行它，显示的随机数会是伪随机数，即每次运行显示的结果会有不同。

3.建议：如果想在一个程序中生成随机数序列，需要至多在生成随机数之前设置一次随机种子。 

看下面这个用来生成一个随机字符串的C++程序：

[cpp]  view plain  copy

1. //rand04.cpp   
2. #include   
3. #include   
4. using namespace std;   
5. int main()   
6. {   
7. int rNum,m=20;   
8. char *ch=new char ;   
9.   
10. for ( int i = 0; i //大家看到了，随机种子会随着for循环在程序中设置多次   
11. srand((unsigned)time(NULL));   
12. rNum=1+(int)((rand()/(double)RAND_MAX)*36); //求随机值   
13. switch (rNum){   
14. case 1: ch='a';   
15. break ;   
16. case 2: ch='b';   
17. break ;   
18. case 3: ch='c';   
19. break ;   
20. case 4: ch='d';   
21. break ;   
22. case 5: ch='e';   
23. break ;   
24. case 6: ch='f';   
25. break ;   
26. case 7: ch='g';   
27. break ;   
28. case 8: ch='h';   
29. break ;   
30. case 9: ch='i';   
31. break ;   
32. case 10: ch='j';   
33. break ;   
34. case 11: ch='k';   
35. break ;   
36. case 12: ch='l';   
37. break ;   
38. case 13: ch='m';   
39. break ;   
40. case 14: ch='n';   
41. break ;   
42. case 15: ch='o';   
43. break ;   
44. case 16: ch='p';   
45. break ;   
46. case 17: ch='q';   
47. break ;   
48. case 18: ch='r';   
49. break ;   
50. case 19: ch='s';   
51. break ;   
52. case 20: ch='t';   
53. break ;   
54. case 21: ch='u';   
55. break ;   
56. case 22: ch='v';   
57. break ;   
58. case 23: ch='w';   
59. break ;   
60. case 24: ch='x';   
61. break ;   
62. case 25: ch='y';   
63. break ;   
64. case 26: ch='z';   
65. break ;   
66. case 27:ch='0';   
67. break;   
68. case 28:ch='1';   
69. break;   
70. case 29:ch='2';   
71. break;   
72. case 30:ch='3';   
73. break;   
74. case 31:ch='4';   
75. break;   
76. case 32:ch='5';   
77. break;   
78. case 33:ch='6';   
79. break;   
80. case 34:ch='7';   
81. break;   
82. case 35:ch='8';   
83. break;   
84. case 36:ch='9';   
85. break;   
86. }//end of switch   
87. cout< }//end of for loop   
88.   
89. cout< return 0;   
90. }   

而运行结果显示的随机字符串的每一个字符都是一样的，也就是说生成的字符序列不随机，所以我们需要把srand((unsigned)time(NULL)); 从for循环中移出放在for语句前面，这样可以生成随机的字符序列，而且每次运行生成的字符序列会不同（呵呵，也有可能相同，不过出现这种情况的几率太小了）。
如果你把srand((unsigned)time(NULL));改成srand(2);这样虽然在一次运行中产生的字符序列是随机的，但是每次运行时产生的随机字符序列串是相同的。把srand这一句从程序中去掉也是这样。

此外，你可能会遇到这种情况，在使用timer控件编制程序的时候会发现用相同的时间间隔生成的一组随机数会显得有规律，而由用户按键command事件产生的一组随机数却显得比较随机，为什么？根据我们上面的分析，你可以很快想出答案。这是因为timer是由计算机时钟记数器精确控制时间间隔的控件，时间间隔相同，记数器前后的值之差相同，这样时钟取值就是呈线性规律的，所以随机种子是呈线性规律的，生成的随机数也是有规律的。而用户按键事件产生随机数确实更呈现随机性，因为事件是由人按键引起的，而人不能保证严格的按键时间间隔，即使严格地去做，也不可能完全精确做到，只要时间间隔相差一微秒，记数器前后的值之差就不相同了，随机种子的变化就失去了线性规律，那么生成的随机数就更没有规律了，所以这样生成的一组随机数更随机。这让我想到了各种晚会的抽奖程序，如果用人来按键产生幸运观众的话，那就会很好的实现随机性原则，结果就会更公正。

最后，我总结两个要点： 
1.计算机的伪随机数是由随机种子根据一定的计算方法计算出来的数值。所以，只要计算方法一定，随机种子一定，那么产生的随机数就是固定的。 
2.只要用户或第三方不设置随机种子，那么在默认情况下随机种子来自系统时钟。

文章转载自：http://blog.csdn.net/shiliangsl0115/article/details/4210767

==============================================================================================================================

一、C++中不能使用random()函数

本文由青松原创并依GPL-V2及其后续版本发放，转载请注明出处且应包含本行声明。

C++中常用rand()函数生成随机数，但严格意义上来讲生成的只是伪随机数（pseudo-random integral number）。生成随机数时需要我们指定一个种子，如果在程序内循环，那么下一次生成随机数时调用上一次的结果作为种子。但如果分两次执行程序，那么由于种子相同，生成的“随机数”也是相同的。

在工程应用时，我们一般将系统当前时间(Unix时间)作为种子，这样生成的随机数更接近于实际意义上的随机数。给一下例程如下：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <ctime>  
3. #include <cstdlib>  
4. using namespace std;  
5.    
6. int main()  
7. {  
8.     double random(double,double);  
9.     srand(unsigned(time(0)));  
10.     for(int icnt = 0; icnt != 10; ++icnt)  
11.         cout << "No." << icnt+1 << ": " << int(random(0,10))<< endl;  
12.     return 0;  
13. }  
14.    
15. double random(double start, double end)  
16. {  
17.     return start+(end-start)*rand()/(RAND_MAX + 1.0);  
18. }  
19. /* 运行结果 
20. * No.1: 3 
21. * No.2: 9 
22. * No.3: 0 
23. * No.4: 9 
24. * No.5: 5 
25. * No.6: 6 
26. * No.7: 9 
27. * No.8: 2 
28. * No.9: 9 
29. * No.10: 6 
30. */  

利用这种方法能不能得到完全意义上的随机数呢？似乎9有点多哦？却没有1,4,7？！我们来做一个概率实验，生成1000万个随机数，看0-9这10个数出现的频率是不是大致相同的。程序如下：

[cpp]  view plain  copy

1. <span style="font-size:12px;">#include <iostream>  
2. #include <ctime>  
3. #include <cstdlib>  
4. #include <iomanip>  
5. using namespace std;  
6.    
7. int main()  
8. {  
9.     double random(double,double);  
10.     int a[10] = {0};  
11.     const int Gen_max = 10000000;  
12.     srand(unsigned(time(0)));  
13.       
14.     for(int icnt = 0; icnt != Gen_max; ++icnt)  
15.         switch(int(random(0,10)))  
16.         {  
17.         case 0: a[0]++; break;  
18.         case 1: a[1]++; break;  
19.         case 2: a[2]++; break;  
20.         case 3: a[3]++; break;  
21.         case 4: a[4]++; break;  
22.         case 5: a[5]++; break;  
23.         case 6: a[6]++; break;  
24.         case 7: a[7]++; break;  
25.         case 8: a[8]++; break;  
26.         case 9: a[9]++; break;  
27.         default: cerr << "Error!" << endl; exit(-1);  
28.         }  
29.       
30.     for(int icnt = 0; icnt != 10; ++icnt)  
31.         cout << icnt << ": " << setw(6) << setiosflags(ios::fixed) << setprecision(2) << double(a[icnt])/Gen_max*100 << "%" << endl;  
32.       
33.     return 0;  
34. }  
35.    
36. double random(double start, double end)  
37. {  
38.     return start+(end-start)*rand()/(RAND_MAX + 1.0);  
39. }  
40. /* 运行结果 
41. * 0: 10.01% 
42. * 1:   9.99% 
43. * 2:   9.99% 
44. * 3:   9.99% 
45. * 4:   9.98% 
46. * 5: 10.01% 
47. * 6: 10.02% 
48. * 7: 10.01% 
49. * 8: 10.01% 
50. * 9:   9.99% 
51. */  
52. </span>  

可知用这种方法得到的随机数是满足统计规律的。

另：在Linux下利用GCC编译程序，即使我执行了1000000次运算，是否将random函数定义了inline函数似乎对程序没有任何影响，有理由相信，GCC已经为我们做了优化。但是冥冥之中我又记得要做inline优化得加O3才行...

不行，于是我们把循环次数改为10亿次，用time命令查看执行时间：
chinsung@gentoo ~/workspace/test/Debug $ time ./test
0: 10.00%
1: 10.00%
2: 10.00%
3: 10.00%
4: 10.00%
5: 10.00%
6: 10.00%
7: 10.00%
8: 10.00%
9: 10.00%

real 2m7.768s
user 2m4.405s
sys 0m0.038s
chinsung@gentoo ~/workspace/test/Debug $ time ./test
0: 10.00%
1: 10.00%
2: 10.00%
3: 10.00%
4: 10.00%
5: 10.00%
6: 10.00%
7: 10.00%
8: 10.00%
9: 10.00%

real 2m7.269s
user 2m4.077s
sys 0m0.025s

前一次为进行inline优化的情形，后一次为没有作inline优化的情形，两次结果相差不大，甚至各项指标后者还要好一些，不知是何缘由...

==================================================================================
   random函数不是ANSI C标准，不能在gcc,vc等编译器下编译通过。可改用C++下的rand函数来实现。

   1、C++标准函数库提供一随机数生成器rand，返回0－RAND_MAX之间均匀分布的伪随机整数。 RAND_MAX必须至少为32767。rand()函数不接受参数，默认以1为种子（即起始值）。 随机数生成器总是以相同的种子开始，所以形成的伪随机数列也相同，失去了随机意义。（但这样便于程序调试）
   2、C++中另一函数srand（），可以指定不同的数（无符号整数变元）为种子。但是如果种子相同，伪随机数列也相同。一个办法是让用户输入种子，但是仍然不理想。
   3、 比较理想的是用变化的数，比如时间来作为随机数生成器的种子。 time的值每时每刻都不同。所以种子不同，所以，产生的随机数也不同。

[cpp]  view plain  copy

1. <span style="font-size:12px;">// C++随机函数（VC program）   
2. #include <stdio.h>   
3. #include <iostream>   
4. #include <time.h>   
5. using namespace std;   
6. #define MAX 100   
7. int main(int argc, char* argv[])   
8. {    srand( (unsigned)time(NULL));//srand()函数产生一个以当前时间开始的随机种子.应该放在for等循环语句前面 不然要很长时间等待   
9. 　　 for (int i=0;i<10;i++)   
10. 　　 cout<<rand()%MAX<<endl;//MAX为最大值，其随机域为0~MAX-1  
11. 　　 return 0;   
12. } </span>  

二、rand()的用法 
   rand()不需要参数，它会返回一个从0到最大随机数的任意整数，最大随机数的大小通常是固定的一个大整数。 这样，如果你要产生0~10的10个整数，可以表达为：
int N = rand() % 11;  这样，N的值就是一个0~10的随机数，如果要产生1~10，则是这样：int N = 1 + rand() % 10; 总结来说，可以表示为：a + rand() % n，其中的a是起始值，n是整数的范围。 　　

   a + rand() % (b-a+1) 就表示ａ～ｂ之间的一个随机数。若要0~1的小数，则可以先取得0~10的整数，然后均除以10即可得到随机到十分位的10个随机小数，若要得到随机到百分位的随机小数，则需要先得到0~100的10个整数，然后均除以100，其它情况依此类推。
   通常rand()产生的随机数在每次运行的时候都是与上一次相同的，这是有意这样设计的，是为了便于程序的调试。若要产生每次不同的随机数，可以使用srand( seed )函数进行随机化，随着seed的不同，就能够产生不同的随机数。
   如大家所说，还可以包含time.h头文件，然后使用srand(time(0))来使用当前时间使随机数发生器随机化，这样就可以保证每两次运行时可以得到不同的随机数序列(只要两次运行的间隔超过1秒)。

文章转自http://www.cnblogs.com/finallyliuyu/archive/2010/10/11/1848130.html