在C语言中，我们一般使用 <stdlib.h> 头文件中的 rand() 函数来生成随机数，它的用法为：

1
int rand (void);

void 表示不需要传递参数。

C语言中还有一个 random() 函数可以获取随机数，但是 random() 不是标准函数，不能在 VC/VS 等编译器通过，所以比较少用。

rand() 会随机生成一个位于 0 ~ RAND_MAX 之间的整数。

RAND_MAX 是 <stdlib.h> 头文件中的一个宏，它用来指明 rand() 所能返回的随机数的最大值。C语言标准并没有规定 RAND_MAX 的具体数值，只是规定它的值至少为 32767。在实际编程中，我们也不需要知道 RAND_MAX 的具体值，把它当做一个很大的数来对待即可。

下面是一个随机数生成的实例：

1
2
3
4
5
6
7
#include <stdio.h>
#include <stdlib.h>
int main(){
    int a = rand();
    printf("%d\n",a);
    return 0;
}

运行结果举例：

1804289383

随机数的本质

多次运行上面的代码，你会发现每次产生的随机数都一样，这是怎么回事呢？为什么随机数并不随机呢？

实际上，rand() 函数产生的随机数是伪随机数，是根据一个数值按照某个公式推算出来的，这个数值我们称之为“种子”。种子和随机数之间的关系是一种正态分布，如下图所示：

种子在每次启动计算机时是随机的，但是一旦计算机启动以后它就不再变化了；也就是说，每次启动计算机以后，种子就是定值了，所以根据公式推算出来的结果（也就是生成的随机数）就是固定的。

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

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

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

下面看这样一个C程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//rand01.c

#include<dos.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.
伪随机数并不是假随机数，这里的“伪”是有规律的意思，就是计算机产生的伪随机数既是随机的又是有规律的。

2.
随机种子来自系统时钟，确切地说，是来自计算机主板上的定时/计数器在内存中的记数值。

3.
随机数是由随机种子根据一定的计算方法计算出来的数值。所以，只要计算方法一定，随机种子一定，那么产生的随机数就不会变。也就是说，伪随机数也是某种对应映射的产物，只不过这个自变量是系统的时间而已

4.
如果你每次调用srand()时都提供相同的种子值，那么，你将会得到相同的随机数序列

重新播种

我们可以通过 srand() 函数来重新“播种”，这样种子就会发生改变。srand() 的用法为：

1
void srand (unsigned int seed);

它需要一个 unsigned int 类型的参数。在实际开发中，我们可以用时间作为参数，只要每次播种的时间不同，那么生成的种子就不同，最终的随机数也就不同。

使用 <time.h> 头文件中的 time() 函数即可得到当前的时间（精确到秒），就像下面这样：

1
srand((unsigned)time(NULL));

有兴趣的读者请猛击这里自行研究 time() 函数的用法，本节我们不再过多讲解。

对上面的代码进行修改，生成随机数之前先进行播种：

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
    int a;
    srand((unsigned)time(NULL));
    a = rand();
    printf("%d\n", a);
    return 0;
}

多次运行程序，会发现每次生成的随机数都不一样了。但是，这些随机数会有逐渐增大或者逐渐减小的趋势，这是因为我们以时间为种子，时间是逐渐增大的，结合上面的正态分布图，很容易推断出随机数也会逐渐增大或者减小。

生成一定范围内的随机数

在实际开发中，我们往往需要一定范围内的随机数，过大或者过小都不符合要求，那么，如何产生一定范围的随机数呢？我们可以利用取模的方法：

1
int a = rand() % 10;    //产生0~9的随机数，注意10会被整除

如果要规定上下限：

1
int a = rand() % 51 + 13;    //产生13~63的随机数

分析：取模即取余，rand()%51+13我们可以看成两部分：rand()%51是产生 0~50 的随机数，后面+13保证 a 最小只能是 13，最大就是 50+13=63。

最后给出产生 13~63 范围内随机数的完整代码：

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(){
    int a;
    srand((unsigned)time(NULL));
    a = rand() % 51 + 13;
    printf("%d\n",a);
    return 0;
}

连续生成随机数

有时候我们需要一组随机数（多个随机数），该怎么生成呢？很容易想到的一种解决方案是使用循环，每次循环都重新播种，请看下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
    int a, i;
    //使用for循环生成10个随机数
    for (i = 0; i < 10; i++) {
        srand((unsigned)time(NULL));
        a = rand();
        printf("%d ", a);
    }
    return 0;
}

结果如下：

因为srand语句在循环内，每一次都用时间做种，程序执行速度很快，所以获取时间精度内，数值不便，于是每一次循环都是一样的（srand中是以时间为参数，放在循环体内，运行速度快，时间还未改变又被当作了参数。），如果把srand（）放在循环外，就能产生不同的不同的序列：结果就是下面这样：

看起来就是想要的结果了

如果我非要把srand（）放在while里面呢，也行，我们可以这样写

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

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
    int a, i;
    //使用for循环生成10个随机数
    for (i = 0; i < 10; i++) {
	srand((unsigned)time(NULL) + (unsigned)rand());
        a = rand();
        printf("%d \n", a);
    }
    return 0;
}

以随机数加时间做种，但是万变不离其宗，最后随机数生成还是靠时间，但是加上随机数之后呢，还取决于你循环里面调用rand（）的次数，不管怎么说，当程序确定，时间确定，生成的随机数都是一样的。