如何在C中生成随机整数？

在C语言中是否有生成随机整数的函数？或者我必须使用第三方库吗？

STL对于C不存在。您必须调用

rand

，或者更好的是，

random

。这些在标准库标题

stdlib.h

中声明

rand

是POSIX，

random

是BSD规范函数

int range_rand(int min_num, int max_num) {
    if (min_num >= max_num) {
        fprintf(stderr, "min_num is greater or equal than max_num!\n"); 
    }
    return min_num + (rand() % (max_num - min_num));
} 

---

rand

和

random

之间的区别在于

random

返回更有用的32位随机数，

rand

通常返回16位数字。BSD MangPoes显示<>代码> RAND 的低位是循环的和可预测的，所以<代码> RAND 对于小数字可能是无用的。

嗯，STL是C++，不是C，所以我不知道你想要什么。但是，如果需要C，则有

rand（）

和

srand（）

函数：

int rand(void);

void srand(unsigned seed);

这些都是ANSI C的一部分。还有

random（）

函数：

long random(void);

但据我所知，

random（）

不是标准的ANSI C。第三方库可能不是个坏主意，但它完全取决于您真正需要生成的数字的随机性。

您想使用

rand（）

。注意（非常重要）：确保为rand函数设置种子。如果没有，则您的随机数不是真正的随机数。这是非常非常重要的。谢天谢地，您通常可以结合使用系统计时和日期来获得一个好的种子

中的

rand（）

函数返回一个介于0和

rand\u MAX

之间的伪随机整数。您可以使用

srand（unsigned int seed）

设置种子

通常的做法是将

%

运算符与

rand（）

结合使用，以获得不同的范围（但请记住，这会在一定程度上影响一致性）。例如：

/* random int between 0 and 19 */
int r = rand() % 20;

#include "sodium.h"

int foo()
{
    char myString[32];
    uint32_t myInt;

    if (sodium_init() < 0) {
        /* panic! the library couldn't be initialized, it is not safe to use */
        return 1; 
    }


    /* myString will be an array of 32 random bytes, not null-terminated */        
    randombytes_buf(myString, 32);

    /* myInt will be a random number between 0 and 9 */
    myInt = randombytes_uniform(10);
}

如果你真的关心一致性，你可以这样做：

/* Returns an integer in the range [0, n).
 *
 * Uses rand(), and so is affected-by/affects the same seed.
 */
int randint(int n) {
  if ((n - 1) == RAND_MAX) {
    return rand();
  } else {
    // Supporting larger values for n would requires an even more
    // elaborate implementation that combines multiple calls to rand()
    assert (n <= RAND_MAX)

    // Chop off all of the values that would cause skew...
    int end = RAND_MAX / n; // truncate skew
    assert (end > 0);
    end *= n;

    // ... and ignore results from rand() that fall above that limit.
    // (Worst case the loop condition should succeed 50% of the time,
    // so we can expect to bail out of this loop pretty quickly.)
    int r;
    while ((r = rand()) >= end);

    return r % n;
  }
}

/*返回范围为[0，n]的整数。
*
*使用rand（），因此受同一种子的影响。
*/
int randint（int n）{
如果（（n-1）=RAND_MAX）{
返回rand（）；
}否则{
//支持更大的n值需要更大的
//结合对rand（）的多个调用的详细实现
断言（n0）；
结束*=n；
//…并忽略rand（）超出该限制的结果。
//（最坏情况下，循环条件应在50%的时间内成功，
//因此，我们可以期望很快摆脱这一循环。）
INTR；
而（（r=rand（））>=end）；
返回r%n；
}
}

FWIW，答案是肯定的，有一个名为

rand

的

stdlib.h

函数；该函数主要针对速度和分布进行调整，而不是针对不可预测性。几乎所有用于各种语言和框架的内置随机函数默认情况下都使用该函数。还有“加密”可预测性差得多，但运行速度慢得多的随机数生成器。这些生成器应用于任何类型的安全相关应用程序。

请查看（间接、移位、累积、添加和计数）。其均匀分布，平均周期长度为2^8295

注意：不要为了安全而使用

rand（）

#包括
#包括
srand（time（NULL））；//初始化，只能调用一次。
int r=rand（）；//返回一个介于0和rand_MAX之间的伪随机整数。

在Linux上，您可能更喜欢使用。
如果您需要比stdlib

提供的伪随机数质量更好的伪随机数，请查看。它也更快。例如，示例实现非常丰富。

让我们来讨论一下。首先，我们使用

srand（）

函数为随机化器设定种子。基本上，计算机可以根据馈送到

srand（）

的数字生成随机数。如果给定相同的种子值，则每次都会生成相同的随机数

因此，我们必须给随机化器植入一个不断变化的值。我们通过使用

time（）

函数为其提供当前时间的值来实现这一点

int range_rand(int min_num, int max_num) {
    if (min_num >= max_num) {
        fprintf(stderr, "min_num is greater or equal than max_num!\n"); 
    }
    return min_num + (rand() % (max_num - min_num));
} 

现在，当我们调用

rand（）

时，每次都会产生一个新的随机数

#包括
int随机数（int最小值，int最大值）；
内部主（空）
{
printf（“最小值：1最大值：40%d\n”，随机数（1,40））；
printf（“最小值：100最大值：1000%d\n”，随机数（1001000））；
返回0；
}
整数随机数（整数最小值，整数最大值）
{
int result=0，low_num=0，hi_num=0；
如果（最小值<最大值）
{
低数值=最小数值；
hi_num=max_num+1；//在输出中包括max_num
}否则{
low_num=max_num+1；//在输出中包括max_num
hi_num=最小_num；
}
srand（时间（空））；
结果=（rand（）%（hi_num-low_num））+low_num；
返回结果；
}

试试这个，我把上面提到的一些概念组合起来：

/*    
Uses the srand() function to seed the random number generator based on time value,
then returns an integer in the range 1 to max. Call this with random(n) where n is an integer, and you get an integer as a return value.
 */

int random(int max) {
    srand((unsigned) time(NULL));
    return (rand() % max) + 1;
}

rand（）

是生成随机数最方便的方法

您也可以从random.org等任何在线服务获取随机数。

\include
#include <stdio.h>
#include <dos.h>

int random(int range);

int main(void)
{
    printf("%d", random(10));
    return 0;
}

int random(int range)
{
    struct time t;
    int r;

    gettime(&t);
    r = t.ti_sec % range;
    return r;
}

#包括
int随机（int范围）；
内部主（空）
{
printf（“%d”，随机（10））；
返回0；
}
int随机（int范围）
{
结构时间t；
INTR；
gettime&t；
r=t.ti_秒百分比范围；
返回r；
}

这是一种在您选择的两个数字之间获取随机数的好方法

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

    #define randnum(min, max) \
        ((rand() % (int)(((max) + 1) - (min))) + (min))

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

    printf("%d\n", randnum(1, 70));
}

#包括
#包括
#包括
#定义随机数（最小值、最大值）\
（（rand（）%（int）（（max）+1）-（min）））+（min））
int main（）
{
srand（时间（空））；
printf（“%d\n”，randnum（1,70））；
}

第一次输出：39

第二次输出：61

第三次输出：65

Y

#include <stdio.h>
#include <stdlib.h>

void main() 
{
    int visited[100];
    int randValue, a, b, vindex = 0;

    randValue = (rand() % 100) + 1;

    while (vindex < 100) {
        for (b = 0; b < vindex; b++) {
            if (visited[b] == randValue) {
                randValue = (rand() % 100) + 1;
                b = 0;
            }
        }

        visited[vindex++] = randValue;
    }

    for (a = 0; a < 100; a++)
        printf("%d ", visited[a]);
}

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <openssl/rand.h>

/* Random integer in [0, limit) */
unsigned int random_uint(unsigned int limit) {
    union {
        unsigned int i;
        unsigned char c[sizeof(unsigned int)];
    } u;

    do {
        if (!RAND_bytes(u.c, sizeof(u.c))) {
            fprintf(stderr, "Can't get random bytes!\n");
            exit(1);
        }
    } while (u.i < (-limit % limit)); /* u.i < (2**size % limit) */
    return u.i % limit;
}

/* Random double in [0.0, 1.0) */
double random_double() {
    union {
        uint64_t i;
        unsigned char c[sizeof(uint64_t)];
    } u;

    if (!RAND_bytes(u.c, sizeof(u.c))) {
        fprintf(stderr, "Can't get random bytes!\n");
        exit(1);
    }
    /* 53 bits / 2**53 */
    return (u.i >> 11) * (1.0/9007199254740992.0);
}

int main() {
    printf("Dice: %d\n", (int)(random_uint(6) + 1));
    printf("Double: %f\n", random_double());
    return 0;
}

uint32_t arc4random(void)
void arc4random_buf(void *buf, size_t bytes)
uint32_t arc4random_uniform(uint32_t limit)
void arc4random_stir(void)
void arc4random_addrandom(unsigned char *dat, int datlen)

/* This is C, not C++ */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h> /* exit */
#include <stdio.h> /* printf */

int urandom_fd = -2;

void urandom_init() {
  urandom_fd = open("/dev/urandom", O_RDONLY);

  if (urandom_fd == -1) {
    int errsv = urandom_fd;
    printf("Error opening [/dev/urandom]: %i\n", errsv);
    exit(1);
  }
}

unsigned long urandom() {
  unsigned long buf_impl;
  unsigned long *buf = &buf_impl;

  if (urandom_fd == -2) {
    urandom_init();
  }

  /* Read sizeof(long) bytes (usually 8) into *buf, which points to buf_impl */
  read(urandom_fd, buf, sizeof(long));
  return buf_impl;
}

#define RAND_IMPL /* urandom(see large code block) | rand | arc4random */

int myRandom(int bottom, int top){
    return (RAND_IMPL() % (top - bottom)) + bottom;
}

#include <time.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    srand((unsigned int)**main + (unsigned int)&argc + (unsigned int)time(NULL));
    srand(rand());

    for (int i = 0; i < 10; i++)
        printf("%d\n", rand());
}

int range_rand(int min_num, int max_num) {
    if (min_num >= max_num) {
        fprintf(stderr, "min_num is greater or equal than max_num!\n"); 
    }
    return min_num + (rand() % (max_num - min_num));
} 

#include "sodium.h"

int foo()
{
    char myString[32];
    uint32_t myInt;

    if (sodium_init() < 0) {
        /* panic! the library couldn't be initialized, it is not safe to use */
        return 1; 
    }


    /* myString will be an array of 32 random bytes, not null-terminated */        
    randombytes_buf(myString, 32);

    /* myInt will be a random number between 0 and 9 */
    myInt = randombytes_uniform(10);
}

srand(time(NULL))

srand(time(NULL) | getHashOfString(outputName))

#include<time.h>
struct timespec nanos;
clock_gettime(CLOCK_MONOTONIC, &nanos)
srand(nanos.tv_nsec);

#include<time.h>
struct timespec nanos;
clock_gettime(CLOCK_MONOTONIC, &nanos)
srand(nanos.tv_nsec | getHashOfString(outputName));

#include <time.h>
#include <stdlib.h>

int main()
{
    srand(time(NULL));
    int lowerLimit = 10, upperLimit = 50;
    int r =  lowerLimit + rand() % (upperLimit - lowerLimit);
    printf("%d", r);
}

#include <immintrin.h>

uint64_t randVal;
if(!_rdrand64_step(&randVal)) {
  // Report an error here: random number generation has failed!
}
// If no error occured, randVal contains a random 64-bit number

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

//generate number in range [min,max)
int random(int min, int max){
    int number = min + rand() % (max - min);
    return number; 
}

//Driver code
int main(){
    srand(time(NULL));
    for(int i = 1; i <= 10; i++){
        printf("%d\t", random(10, 100));
    }
    return 0;
}

int gUrandomFd = -1;

int urandom_open(void)
{
    if (gUrandomFd == -1) {
        gUrandomFd = open("/dev/urandom", O_RDONLY);
    }

    if (gUrandomFd == -1) {
        fprintf(stderr, "Error opening /dev/urandom: errno [%d], strerrer [%s]\n",
                  errno, strerror(errno));
        return -1;
    } else {
        return 0;
    }
}


void urandom_close(void)
{
    close(gUrandomFd);
    gUrandomFd = -1;
}


//
// This link essentially validates the merits of /dev/urandom:
// http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers/
//
int getRandomBuffer(uint8_t *buf, int size)
{
    int ret = 0; // Return value

    if (gUrandomFd == -1) {
        fprintf(stderr, "Urandom (/dev/urandom) file not open\n");
        return -1;
    }

    ret = read(gUrandomFd, buf, size);

    if (ret != size) {
        fprintf(stderr, "Only read [%d] bytes, expected [%d]\n",
                 ret, size);
        return -1;
    } else {
        return 0;
    }
}