Question

How to generate an 8 digits random number in C++

Answer 1

#include <iostream>
#include <random>

constexpr int N = 20;

int main() {
    // 1. Seed the Mersenne Twister engine using hardware entropy
    std::random_device rd;
    std::mt19937 gen(rd());

    // 2. Define inclusive bounds for an 8-digit number (10,000,000 to 99,999,999)
    std::uniform_int_distribution<long> dist(10000000L, 99999999L);

    // 3. Generate and print N numbers
    for (int i = 0; i < N; ++i) {
        std::cout << dist(gen) << '\n';
    }

    return 0;
}
 


/*
run:
 
70142599
94784091
70904381
56740507
27731207
38686978
24727015
63697454
95750655
92930253
17857967
58737101
65481854
73552451
18146514
13403841
66878578
91976718
90449609
77898416
 
*/

 

70+ SQL courses for beginners and professionals

Answer 2

#include <iostream>
#include <random>
#include <string>
#include <iomanip>
#include <sstream>

/**
 * Class responsible for generating random numbers and codes.
 * Encapsulating state ensures proper seeding and thread-safe engine handling.
 */
class RandomGenerator {
public:
    RandomGenerator() 
        // Seed the Mersenne Twister generator using non-deterministic hardware entropy
        : rd_(), gen_(rd_()) {}

    /**
     * Generates an 8-digit random integer between 10,000,000 and 99,999,999 (inclusive).
     * Guaranteed no leading zeros (starts with 1-9).
     *
     * @return An 8-digit integer value.
     */
    long generate8DigitNumber() {
        // Uniform distribution across [10,000,000, 99,999,999]
        std::uniform_int_distribution<long> dist(10'000'000L, 99'999'999L);
        
        return dist(gen_);
    }

    /**
     * Generates an 8-digit string code between "00000000" and "99999999".
     * Preserves leading zeros using string formatting, suitable for OTPs/PINs.
     *
     * @return An 8-character numeric std::string.
     */
    std::string generate8DigitCode() {
        std::uniform_int_distribution<long> dist(0L, 99'999'999L);
        long raw_value = dist(gen_);

        std::ostringstream oss;
        // Format with leading zeros to guarantee exact 8-character width
        oss << std::setw(8) << std::setfill('0') << raw_value;
        
        return oss.str();
    }

private:
    std::random_device rd_; // Hardware entropy source for seeding
    std::mt19937 gen_;       // Mersenne Twister 19937 PRNG engine
};

int main() {
    // Instantiate the generator (seeds engine once upon creation)
    RandomGenerator rng;

    // 1. Generate an 8-digit mathematical integer [10000000, 99999999]
    long random_number = rng.generate8DigitNumber();
    std::cout << "Generated 8-digit integer: " << random_number << '\n';

    // 2. Generate an 8-digit string code [00000000, 99999999] preserving leading zeros
    std::string random_code = rng.generate8DigitCode();
    std::cout << "Generated 8-digit string code: " << random_code << '\n';
}


/*
run:
 
Generated 8-digit integer: 93425832
Generated 8-digit string code: 68581270
 
*/

 

70+ SQL courses for beginners and professionals

Answer 3

#include <iostream>
#include <cstdlib>
#include <ctime>
  
int generate_4_digits_random_number() {
    return rand() % 90000000 + 10000000; // // numbers from 10000000 to 99999999
}
  
int main() {
    srand(time(nullptr)); 
  
    for (int i = 0; i < 10; i++) {
        std::cout << generate_4_digits_random_number() << std::endl;
    }
}
 
 
 
/*
run:
 
94667090
10332536
31926393
59427814
97580255
45752345
65366016
34930345
41869440
29318590
 
*/

 

70+ SQL courses for beginners and professionals