C的随机数函数

rand 和 srand 函数

在 C 语言中使用 rand 函数产生一个随机数函数。并在 stdlib.h 中定义 rand 产生的随机数最大是 RAND_MAX，在 4 个字节下，可以表示的最大正数范围是 2147483647（int 类型）。

rand 函数的原型如下：

#includ <stdlib.h>
int rand (void)

rand 函数在调用时，先查询是否调用过 srand 函数，因为使用 srand 函数可以设置种子，如果有那么它会自动调用 srand(seed) 一次来初始化它的起始值。如果没有之前没有调用 srand(seed)，那么系统会给 seed 赋初始值，即 srand(1) 自动调用它一次。

srand 函数原型如下：

void srand(unsigned int seed);

这个函数需要提供一个种子，如 srand(1)，用来初始化种子。

rand() 函数产生随机数时，如果用 srand(seed) 播下种子后，一旦种子相同，产生的随机数序列是相同的。当然很多时候刻意让 rand() 产生的随机数随机化，用时间作种子 srand(time(NULL))，这样每次运行程序的时间肯定是不相同的，产生的随机数肯定就不一样了。

我们常常使用系统时间来初始化，使用 time 函数来获取系统时间，得到的值是一个时间戳，即从 1970 年 1 月 1 日 0 点到现在时间的秒数，然后将得到的 time_t 类型数据转化为 unsigned int 的数，然后再传给srand函数，用法如下：

srand((unsigned int)time(NULL));

如果仍然觉得时间间隔太小，可以在 (unsigned)time(0) 或者 (unsigned)time(NULL) 后面乘上某个合适的整数。 例如:

srand((unsigned)time(NULL)*10)

还有另外一种初始化种子的方式如下，用进程的pid作为种子值seed，在同一个程序中，这样的种子的值是相同的。

srand((unsigned int)getpid())

我们来测试一下 rand 函数的种子：

int main() {
    unsigned int seed = 123;
    srand(seed);
    cout << rand() << endl;
    cout << rand() << endl;
    cout << rand() << endl;
    cout << rand() << endl;

    seed = 456;
    srand(seed);
    cout << rand() << endl;
    cout << rand() << endl;

    seed = 123;
    srand(seed);
    cout << rand() << endl;
    cout << rand() << endl;
    cout << rand() << endl;
    cout << rand() << endl;                     
}

运行结果是：

$ ./test 
128959393
1692901013
436085873
748533630
1929505231
1800653403
128959393
1692901013
436085873
748533630

可以看到，前面四个是把 123 当成种子得到的随机数，变成 456 后，接下来两个随机数都发生了变化，接着又变回 123 得到的四个随机数与最先 4 个随机数相同，所以可以得到结论：一旦种子相同，产生的随机数序列是相同的。也可以通过此方法得出，在 rand 函数没有之前没有调用 srand(seed)，系统默认以 srand(1) 自动调用它一次。

rand 函数的使用

如果想要表示一个数是从 0 开始到最大值的，比如说，想要产生一个 0-99 之间的随机数，那么用法如下：

int num = rand() % 100；

如果想要产生一个数是从 3 开始到最大值的，比如说，想要产生一个 3-100 之间的随机数，那么用法如下：

int num = rand() % 100 + 3;

rand_r 函数

由于 rand() 函数不是线程安全的函数，多线程应使用 rand_r 函数。在 Linux 下，很多以 _r 结尾的函数都表示线程安全的。推荐使用 rand_r 函数产生随机数。

rand_r 函数的原型如下：

int rand_r(unsigned int *seedp);

我们知道，所谓随机种子，其实是每一个种子会有一串看似随机的固定序列，每次只取下一个出来，整体都近乎是随机分布的。每一次改变随机种子变量的值，这个随机数都会重新开始。这样其实能带来一个副产品般的好处，结果可以重现，便于测试。观察如下实例的运行结果可知：

int main()
{
    unsigned int seed = 123;
    cout << rand_r(&seed) << endl;
    cout << rand_r(&seed) << endl;
    cout << rand_r(&seed) << endl;
    cout << rand_r(&seed) << endl;
    seed = 456;
    cout << rand_r(&seed) << endl;
    cout << rand_r(&seed) << endl;
    seed = 123;
    cout << rand_r(&seed) << endl;
    cout << rand_r(&seed) << endl;
    cout << rand_r(&seed) << endl;
    cout << rand_r(&seed) << endl;
}

运行结果：

./test
612365165
943759613
348315775
934720068
330694396
527683227
612365165
943759613
348315775
934720068

rand_r 只关心变量本身，如果换成一个局部变量，随机值就不会改变。如下：

unsigned int seedp = 123;

int getRand()
{
    unsigned int seed = seedp;
    return rand_r(&seed);
}

int main()
{
    cout << getRand() << endl;
    cout << getRand() << endl;
    cout << getRand() << endl;
    seedp = 456;
    cout << getRand() << endl;
    cout << getRand() << endl;
    cout << getRand() << endl;
    return 0;
}

运行结果：

$ ./test 
612365165
612365165
612365165
330694396
330694396
330694396

如果将 getRand() 函数改为如下：

int getRand()
{
    return rand_r(&seedp);
}

运行结果将发生改变：

$ ./test 
612365165
943759613
348315775
330694396
527683227
1519471813

rand_r 与类函数

rand_r() 不能用于 const 的类函数，因为如果 seedp 作为成员变量的话，rand_r() 要改变成员变量。除非 seedp 作为 static 的全局变量。见代码如下：

class CRand
{
public:
    CRand() {}
    unsigned int getRand() const { return rand_r(&seedp); }
    void setSeetp(const unsigned int& seed)
    {
        seedp = seed;
    }
private:
    static unsigned int seedp;
};

unsigned int CRand::seedp = time(NULL);

int main()
{
    CRand cr;
    cout << cr.getRand() << endl;
    cout << cr.getRand() << endl;
    cout << cr.getRand() << endl;
    cout << cr.getRand() << endl;
    cr.setSeetp(123);
    cout << cr.getRand() << endl;
    cout << cr.getRand() << endl;
    cout << cr.getRand() << endl;
    cout << cr.getRand() << endl;
}

运行结果：

$ ./test 
269263084
1659874951
1191687629
406590481
612365165
943759613
348315775
934720068

但是如果在多线程运行环境下，该程序并不是安全的，只是作为基本示例程序。

实际应用：使用 seed_r 函数实现固定范围随机数。

#define RAND_MAX 2147483647

unsigned int seedp = time(NULL);

int randBetween(int min, int max)
{
    if (min == max)
        return min;
    else if (min > max)
        return max + (int)(((double)min - (double)max + 1.0) * rand_r(&seedp) / (RAND_MAX + 1.0));
    else
        return min + (int)(((double)max - (double)min + 1.0) * rand_r(&seedp) / (RAND_MAX + 1.0));
}

在 glibc 中 rand_r 函数实现如下：

int rand_r (unsigned int *seed)
{
  unsigned int next = *seed;
  int result;

  next *= 1103515245;
  next += 12345;
  result = (unsigned int) (next / 65536) % 2048;

  next *= 1103515245;
  next += 12345;
  result <<= 10;
  result ^= (unsigned int) (next / 65536) % 1024;

  next *= 1103515245;
  next += 12345;
  result <<= 10;
  result ^= (unsigned int) (next / 65536) % 1024;

  *seed = next;

  return result;
}

参考：

• https://blog.csdn.net/lvyibin890/article/details/80141412

• https://blog.csdn.net/made_in_chn/article/details/6604500