C++使用getrandom生成随机数求助：制作数学测验遇time(0)精度问题

Hey there! Let's tackle your random number generator problem for that math quiz you're building in C++. I totally get the frustration with time(0)'s 1-second precision, and the getrandom suggestion from NetBeans can feel confusing since it's not a standard C++ function. Let's break this down step by step.

1. Why time(0) isn't great for your use case #

The issue with srand(time(0)) is exactly what you noticed: it only changes once per second. If you restart your quiz program quickly (within the same second), you'll get the exact same sequence of "random" numbers. That's not ideal for a math quiz where you want fresh questions every time.

2. Using getrandom() on Linux #

First off, getrandom() is a Linux-specific system call (it's not part of standard C++), which is why you might have struggled to find general resources. It pulls random data directly from the kernel's entropy pool, making it way more reliable than time(0). Here's how to use it:

First, include the necessary header:

#include <sys/random.h>

Then, write a helper function to generate a random 32-bit integer (you can adjust the type if you need larger/smaller values):

#include <cstdint>
#include <stdexcept>

uint32_t generate_random() {
    uint32_t rand_val;
    // Get 4 bytes of random data; 0 means default behavior (blocks if entropy is low)
    ssize_t bytes_read = getrandom(&rand_val, sizeof(rand_val), 0);
    
    if (bytes_read != sizeof(rand_val)) {
        throw std::runtime_error("Failed to generate random number with getrandom");
    }
    return rand_val;
}

You can use this value to seed a pseudo-random engine like rand() (though modern C++ alternatives are better), or directly map it to the range you need for your quiz questions (e.g., rand_val % 100 + 1 for numbers 1-100—just note that modulo can introduce slight bias, which we'll fix later).

Alternative: Reading from /dev/urandom #

The other suggestion from NetBeans, /dev/urandom, is a character device that provides random data. It's similar to getrandom() but uses file I/O instead of a system call. Here's how to read from it:

#include <fstream>
#include <cstdint>
#include <stdexcept>

uint32_t read_from_urandom() {
    std::ifstream urandom_file("/dev/urandom", std::ios::binary);
    if (!urandom_file.is_open()) {
        throw std::runtime_error("Couldn't open /dev/urandom");
    }
    
    uint32_t rand_val;
    urandom_file.read(reinterpret_cast<char*>(&rand_val), sizeof(rand_val));
    if (!urandom_file) {
        throw std::runtime_error("Failed to read from /dev/urandom");
    }
    
    return rand_val;
}

3. The cross-platform, modern C++ solution (recommended!) #

If you want your quiz to work on Windows, macOS, or Linux without changing code, forget about system-specific calls and use C++11's <random> library. It's part of the standard, well-documented, and way more robust than rand()/srand().

Here's a complete example tailored to your math quiz:

#include <random>
#include <iostream>

int main() {
    // Initialize a random device to get a high-quality seed
    std::random_device rd;
    // Use the Mersenne Twister engine (fast, high-quality pseudo-random generator)
    std::mt19937 random_engine(rd());
    // Define a distribution for integers between 1 and 100 (adjust as needed)
    std::uniform_int_distribution<int> number_dist(1, 100);
    
    // Generate random numbers for your quiz
    int num1 = number_dist(random_engine);
    int num2 = number_dist(random_engine);
    
    std::cout << "What's " << num1 << " + " << num2 << "? ";
    int answer;
    std::cin >> answer;
    
    if (answer == num1 + num2) {
        std::cout << "Correct! 🎉" << std::endl;
    } else {
        std::cout << "Oops, wrong answer. The correct one is " << num1 + num2 << "." << std::endl;
    }
    
    return 0;
}

This approach avoids the bias of modulo operations, gives you truly random seeds (thanks to std::random_device), and works across all modern C++ compilers.

4. Quick recommendations #

• If you're only targeting Linux, getrandom() or /dev/urandom are solid upgrades over time(0).
• For cross-platform code (or just cleaner, modern C++), stick with the <random> library—it's the industry standard now.
• Avoid rand() and srand() entirely if you can; they're legacy functions with poor randomness quality.

内容的提问来源于stack exchange，提问作者Doot