rand() Function in C++ | Board Infinity

Development of various programs requires the generation of random numbers and it is widely used in different areas such as simulation, games, statistical software, and testing.

However, it is important to know how the `rand() in C++` function is implemented, what it cannot do, and how it has to be used. For example, if there is no seeding, the function will generate the same numbers each time a program is run which causes a problem of predictability in applications that involve gaming or simulations.

This blog deals with the specifics of the `rand()` function in C++, shows how to make generated values more varied with the help of `srand()`, provides an overview of `rand()` uses, pitfalls, and answers frequently asked questions about this function so that you can use `rand()` in your C programs to the best advantage.

What is the `rand()` Function in C++?

The `rand()` function (C++ random number generator) is a part of the C Standard Library and can be used to generate pseudo-random numbers in C++ code easily as rand() has been carried over to C++ from C to maintain compatibility.

Although these numbers look arbitrary, they’re actually calculated from deterministic equations and are therefore capable of being reproduced other times and thus make the `rand()` efficient for a great many applications where strictly random numbers are not necessary. This function is highly appreciated for its convenience and the absence of any difficulties in launching it.

It is declared in the stdlib.h header file:

<cstdlib>

The function provides a random integer number between 0 and the inclusive maximum value, which is entered in the constant named RAND_MAX from the <cstdlib> header. Of course, the value of RAND_MAX changes with the implementation definition, but it is declared always to be greater than or equal to 32767.

#Syntax: c++ random

int rand(void);

Key Characteristics:

Generates a random integer in the range between 0 (inclusive) and a number greater than that maximum-inclusive integer [0, RAND_MAX].
The randomness is pseudo-random, this makes the sequences predictable by a given seed value.

How Does `rand()` Work?

The C++ rand()'s function on the other hand is pseudo-random and is calculated deterministically. By default, such a sequence does not change with time meaning that, each time the program is run, the same sequence of numbers is yielded. This is because it uses a fixed initial seed value until it is changed by the function called srand().

Internally they are computed as a deterministic function of the seed using mathematical formulas to produce pseudo-random numbers. However, the nature of the sequence seems completely arbitrary, the sequence can be replicated if the seed remains fixed.

Seeding Random Numbers with `srand()`

To generate fewer sequential numbers in the output of the C++ rand() function we use the srand() function to seed the number. This function seeds the random number generator, and, if you call rand(), at a later time you will get different numbers.

#Syntax: c++ random and srand()

void srand(unsigned int seed);

Here is a simple example of how to use srand() with rand():

#c++ random for seeding random numbers with srand()

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // Use current time as seed for random number generator
    std::srand(std::time(nullptr));

    // Generate and print random numbers
    for (int i = 0; i < 5; i++) {
        std::cout << "Random Number " << i + 1 << ": " << std::rand() << std::endl;
    }

    return 0;
}

In this example:

Here the time(nullptr) function returns the current time in terms of a number of seconds since the epoch which acts as the seed.
With every run of the program separate sequence of random numbers would be generated.

Practical Applications of C++ `rand()`

Simulations
These types of computations can be called stochastic or probabilistic because very often real-world simulation involves input data randomization, for example - weather or traffic conditions.
Games
rand() can be used in various games such as games where numbers are applied to mix cards, roll a die, or put barriers.
Statistical Sampling
In data analysis, most especially in statistics, random sampling provides for bias-free sample selection.
Testing
Random inputs can be applied to check the weak points of algorithms or systems.
Basic Encryption
Despite the fact rand() is not secure for cryptographic purposes, one sees it being used occasionally for lightweight obfuscation.

Limitations of `rand()`

While rand() in C++ is convenient, it has several limitations:

Predictability
Outputs generated from rand() are quasi or pseudo-random, that is, they are predictable when the seed value is known.
Limited Range
This rand() function has its range from 0 to RAND_MAX, and this is often not so suitable for some applications. Users frequently apply output scaling to a preferred range, which, if not taken care of properly, adds biases to the system.
The Absence of Cryptography
As stated earlier rand() is deterministic, thus making it unfit for use in cryptography.
Behavior Dependent on Implementation
The magnitude of RAND_MAX and the degree of randomness demonstrated may well differ from compiler to compiler.

Code Examples - C++ random

1. Generating Random Numbers in a Specific Range

To generate random numbers within a specific range [min, max], we can use the following formula:

min + rand() % (max - min + 1);

#c++ random for generating random numbers in specific range

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

int main() {
    int min = 10, max = 50;

    // Seed the random number generator
    srand(time(NULL));

    // Generate random numbers in the range [min, max]
    for (int i = 0; i < 5; i++) {
        int random_number = min + rand() % (max - min + 1);
        printf("Random Number %d: %d\n", i + 1, random_number);
    }

    return 0;
}

2. Generating Floating-Point Random Numbers

If you need random floating-point numbers in the range [0, 1), you can normalize the output of rand():

random_float = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);

#c++ random generating floating point random numbers

#include <iostream>
#include <cstdlib>
#include <ctime>

int main() {
    // Seed the random number generator
    std::srand(std::time(nullptr));

    // Generate a random float between 0 and 1
    float random_float = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);

    // Print the random float
    std::cout << "Random Float: " << random_float << std::endl;

    return 0;
}

Conclusion

The rand() function provided in C++ language is another simple yet effective library that helps users generate pseudo-random numbers. Even though it is not designed for such purposes as cryptography or high-security applications, such as financial and other very secure systems, it stands out as a preferred choice in the fields of simulations, games, or other testing projects.

If you properly use the srand() function, then the above sequence of random numbers can be less easy to guess and thus can be well used for many applications. Knowing what rand() is capable and incapable of doing, as well as how to use it well, will allow you to get the best out of the function.

What is the rand() Function in C++?