In this article, we’ll go over the functions needed to create a random number generator in C++. In the world of computers, random numbers form an essential component to add the flavor of anonymity and security.
A random number generator forms the backbone of creating pseudo-random numbers.
The idea behind pseudo-random numbers is that a computer does not have a thinking process to select a random number. So even though an output number produced may seem random, the values are mathematically computed.
The srand() function in C++ can perform pseudo-random number calculation. This function requires a seed value which forms the basis of computation of random numbers.
srand(unsigned int seed_value)
With the help of the seed value, srand()
sets the stage for the generation of pseudo-random numbers by the rand()
function.
int random = rand();
And Voila! We have achieved the simple task of generating a random number. However, the hard part is to understand the concept behind the random number generators.
The seed value holds the key to the series of random numbers. The set of numbers calculated will be similar if the same seed value is provided to the function.
The default seed value for the srand()
function is 1
, therefore a rand() function call without providing a fresh seed value will still fetch us a string of random numbers. The problem here is that every time you run the program with the seed value, the output will remain the same.
A simple solution to our problem is using a fresh seed value each time we run the program. What changes every second? - Time. We used the concept of the current timestamp being the current seed value.
You can create a timestamp by using:
time_t current_time = time(NULL);
The current_time
variable holds the number of seconds passed since January, 1970. This value is passed to the srand()
function and then we get a fresh sequence of pseudo-random numbers.
We can skip the initialization of timestamp to a variable and simply pass the timestamp to the function.
srand((unsigned) time(NULL));
The seed value is provided once in a program no matter how many random numbers are to be generated.
The following code demonstrates the proper generation of a random number.
#include<iostream>
#include<cstdlib>
using namespace std;
int main(){
// Providing a seed value
srand((unsigned) time(NULL));
// Get a random number
int random = rand();
// Print the random number
cout<<random<<endl;
return 1;
}
Output:
1897776064
The number generated is too huge for proper usage in normal calculations.
There is a need to restrict the random numbers within a certain range. For this specific purpose, we use the modulus %
operator.
For instance, in order to generate random numbers from 0 to 9, we can use:
int random = rand() % 10;
Similarly, if we need to fetch random numbers from 1 to 9, we use:
int random = 1 + (rand() % 9);
The general equation can be stated as:
int random = offset + (rand() % range);
In the above equation:
For instance, in a set of random numbers between 10 - 100, we have offset as 10 and range as 91.
Let us run an example of a program that prints 5 random numbers between 100 and 200.
#include<iostream>
#include<cstdlib>
using namespace std;
int main(){
// Providing a seed value
srand((unsigned) time(NULL));
// Loop to get 5 random numbers
for(int i=1; i<=5; i++){
// Retrieve a random number between 100 and 200
// Offset = 100
// Range = 101
int random = 100 + (rand() % 101);
// Print the random number
cout<<random<<endl;
}
return 1;
}
Output:
144
175
162
137
200
To clarify, if no seed value is provided, the output for the above program will be the same every time we run it. Even though the random numbers within the set are different, the complete set will be identical.
The power of random number generation may seem limited, but it is otherwise. Therefore, let us look at a few uses of RNGs.
Cryptography
Unpredictability is considered a measure of security in the field of cryptography. Therefore, there is significant use of Random Number Generators such as keys and nonces.
Games
The traditional games included dices and shuffling of cards to introduce randomness to the game, thereby, adding fun and uncertain results. Similarly, modern game development has a concept of pre- and post- randomness that adds an extra dimension to the game.
Randomized Algorithm
In these algorithms, there is a degree of randomness introduced to an already known algorithm. Most importantly, the purpose of these algorithms is to achieve better performance by trading-off the probability of success.
The RNGs or PRNGs (Pseudo-Random Number Generators) are the building blocks of modern cyber-security and cryptography. The basic principle of these RNGs lie in some computation providing different numbers, that seem random.
We hope this article was understandable to the reader. Feel free to comment below for any queries or suggestions.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.