C++ create a random number generator 🎲

Metadata

• Date :: 12-04-2025
• Tags :: cpp

---

Notes

Detailed Notes on Generating Random Numbers in C++

In C++, generating random numbers is a common requirement for tasks such as simulating dice rolls, creating randomized test data, or adding unpredictability in games. While true randomness is difficult to achieve in programming, C++ provides pseudo-random numbers, which are numbers that appear random but are generated using a deterministic process. They are close enough to random for most practical purposes.

1. What Are Pseudo-Random Numbers?

Pseudo-random numbers are generated using an algorithm, which produces a sequence of numbers that seem random but are actually determined by a starting value called the seed. These numbers are not truly random because, given the same seed, they will always produce the same sequence.

2. Using rand() for Random Number Generation

In C++, the rand() function is used to generate pseudo-random numbers. By default, rand() produces a random number between 0 and 32,767 (the range depends on the system). However, you can adjust the range and behavior of rand() using modulus and arithmetic.

3. Initializing the Random Number Generator

To generate pseudo-random numbers, you need to initialize the random number generator. This is done by calling the srand() function, which “seeds” the random number generator with a starting value.

Steps to Initialize the Random Number Generator:

1. Call srand() to set the seed.
2. The seed is often set using the current calendar time to ensure that you get different random numbers every time the program is run.
3. Use time(NULL) to get the current time in seconds, which ensures a unique seed for each run.

#include <iostream>
#include <cstdlib>
#include <ctime>
 
int main() {
    srand(time(NULL));  // Initialize random number generator with current time
    int num = rand();   // Generate a random number
    std::cout << "Random Number: " << num << std::endl;
    return 0;
}
 

Explanation:

• srand(time(NULL)): This initializes the random number generator using the current time as a seed. This ensures that each execution of the program produces different random numbers.
• rand(): This generates the pseudo-random number.

Output Example:

Random Number: 3231

The generated number can vary depending on the time the program is executed.

4. Limiting the Range of Random Numbers

By default, rand() produces a number between 0 and 32,767. However, in most cases, you may want to limit the range of the random numbers to fit a specific range, like rolling a 6-sided dice or picking a random number between 1 and 100.

To limit the range, you can use the modulus operator (%), which gives the remainder of a division operation.

Example: Rolling a Six-Sided Dice (1 to 6)

To generate a random number between 1 and 6 (like rolling a dice), you can use the modulus operator with 6, and then add 1 to shift the range.

#include <iostream>
#include <cstdlib>
#include <ctime>
 
int main() {
    srand(time(NULL));  // Initialize random number generator
    int num = rand() % 6 + 1;  // Generate a random number between 1 and 6
    std::cout << "Rolled a 6-sided dice: " << num << std::endl;
    return 0;
}
 

Explanation:

• rand() % 6: This generates a number between 0 and 5.
• + 1: Shifts the range to be between 1 and 6.

Output Example:

Rolled a 6-sided dice: 3

5. Generating Random Numbers with Different Ranges

You can generate random numbers within any desired range by using the modulus operator with the upper limit of the range and adjusting the result with addition.

Example 1: Rolling a 20-Sided Dice (1 to 20)

To generate a number between 1 and 20, you can use:

#include <iostream>
#include <cstdlib>
#include <ctime>
 
int main() {
    srand(time(NULL));  // Initialize random number generator
    int num = rand() % 20 + 1;  // Generate a random number between 1 and 20
    std::cout << "Rolled a 20-sided dice: " << num << std::endl;
    return 0;
}
 

Output Example:

Rolled a 20-sided dice: 14

Example 2: Random Number Between 1 and 100

For a number between 1 and 100:

#include <iostream>
#include <cstdlib>
#include <ctime>
 
int main() {
    srand(time(NULL));  // Initialize random number generator
    int num = rand() % 100 + 1;  // Generate a random number between 1 and 100
    std::cout << "Random Number between 1 and 100: " << num << std::endl;
    return 0;
}
 

Output Example:

Random Number between 1 and 100: 67

6. Rolling Multiple Dice

You can easily roll multiple dice by generating several random numbers, one for each die.

Example: Rolling Three 6-Sided Dice

#include <iostream>
#include <cstdlib>
#include <ctime>
 
int main() {
    srand(time(NULL));  // Initialize random number generator
 
    // Roll three 6-sided dice
    int num1 = rand() % 6 + 1;
    int num2 = rand() % 6 + 1;
    int num3 = rand() % 6 + 1;
 
    std::cout << "Rolls: " << num1 << " " << num2 << " " << num3 << std::endl;
    return 0;
}
 

Output Example:

Rolls: 5 2 2

The output will vary with each run of the program since the numbers are generated randomly.

7. Considerations on Randomness

• Pseudo-Random: The numbers generated by rand() are not truly random, but are generated using an algorithm that produces a sequence of numbers based on a starting value (the seed).
• Reproducibility: If you use the same seed (e.g., the same time), the same sequence of random numbers will be generated.
• True Randomness: For applications that require true randomness (such as cryptographic security), you need specialized libraries that pull random values from external sources (e.g., hardware devices or atmospheric noise).

8. Best Practices

• Seeding: Always use srand() with a changing value (like the current time) to avoid getting the same random sequence each time you run your program.
• Range Control: When generating random numbers, always ensure that the range is properly adjusted using modulus and addition.
• Efficiency: For simple games or applications, rand() works fine, but for high-performance applications, consider alternatives like the C++11 <random> library.

Conclusion

Generating random numbers in C++ is a crucial skill, especially for games or simulations. While the numbers generated by rand() are not truly random, they are sufficiently random for most purposes. By seeding the random number generator with srand() and using the modulus operator to control the range, you can easily generate numbers for things like dice rolls, random events, or random sampling.

---

References

• Video