Random Number Generator in C: Using rand() and srand() Effectively

The random number generator in C plays a crucial role in various applications, from gaming to security. Whether you’re creating dice rolls, lottery games, or encryption keys, understanding how randomness works in C is essential. In addition, random number generator in C is so important, that every top-tier software development course focus on this particular topic.

In this guide, we'll also explore different ways to generate random numbers in C, covering everything from the basics to advanced techniques. You'll also find unique code examples, their outputs, and a detailed breakdown of each one.

How Random Number Generator in C Works

C does not have a true random number generator—instead, it provides functions to generate pseudo-random numbers. This means the numbers appear random but follow a predictable sequence based on a starting value (seed).

The most common functions used in C for generating random numbers are:

• rand() – Generates a pseudo-random integer.
• srand(seed) – Sets the seed for rand().
• time(NULL) – Often used as a seed for better randomness.

By default, rand() produces the same sequence of numbers each time you run the program unless you seed it with a unique value. Let’s see this in action.

Generating Random Numbers Using rand() and srand()

You can try and test this code on any of your machine with the compatible IDEs. However, for Linux-based system, you need to follow specialized C compiling instructions, otherwise it can create additional complexities.

Once, you’re ready with your IDE, just copy and paste the code to see its functionality in real-time. Rest, go through the explanation to understand how random number generator in C is working at its core.

Code Example 1: Generating Random Numbers Without srand()

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

int main() {
    printf("Random numbers without seeding:\n");
    for(int i = 0; i < 5; i++) {
        printf("%d\n", rand());
    }
    return 0;
}

Output: (Same every time you run it)

1804289383
846930886
1681692777
1714636915
1957747793

Explanation:

1. This program generates five random numbers using rand().
2. Since we haven't used srand(), the sequence remains the same each time the program runs.
3. rand() pulls numbers from an internal sequence determined by the compiler’s implementation of the C standard library.
4. Without a changing seed, the output sequence is predictable.

Code Example 2: Using srand() for Different Outputs

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

int main() {
    srand(time(NULL)); // Seed based on the current time
    printf("Random numbers with seeding:\n");
    for(int i = 0; i < 5; i++) {
        printf("%d\n", rand());
    }
    return 0;
}

Output: (Different every time you run it)

1289473104
987343102
1348172312
874902347
2039481258

Explanation:

1. srand(time(NULL)) seeds the random number generator with the current timestamp.
2. Since time changes every second, running the program at different times results in different sequences.
3. time(NULL) fetches the number of seconds elapsed since January 1, 1970 (Unix epoch).
4. The seed modifies the starting point of the pseudo-random sequence, making the numbers appear more random.

Code Example 3: Generating Random Numbers in a Range

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

int main() {
    srand(time(NULL));
    int lower = 10, upper = 50;
    printf("Random numbers between %d and %d:\n", lower, upper);
    for(int i = 0; i < 5; i++) {
        printf("%d\n", (rand() % (upper - lower + 1)) + lower);
    }
    return 0;
}

Output:

23
49
34
17
42

Explanation:

1. rand() % (upper - lower + 1) generates numbers within a given range.
2. % (upper - lower + 1) ensures the value never exceeds the upper limit.
3. Adding lower shifts the result to start at the desired minimum value.
4. The range logic works because rand() produces numbers between 0 and RAND_MAX.

Code Example 4: Generating Random Floating-Point Numbers

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

int main() {
    srand(time(NULL));
    printf("Random floating-point numbers between 0 and 1:\n");
    for(int i = 0; i < 5; i++) {
        printf("%.4f\n", (double)rand() / RAND_MAX);
    }
    return 0;
}

Output:

0.4573
0.8291
0.2156
0.9823
0.3728

Explanation:

1. rand() / RAND_MAX normalizes values between 0.0 and 1.0.
2. The division ensures the output remains within a floating-point range.
3. Using %.4f limits the decimal precision to four places.

Random Number Generator in C: rand() vs srand()

Best Practices for Using Random Number Generator in C

To ensure optimal randomness and avoid common pitfalls, follow these best practices when using random number generator in C.

1. Always Seed the Random Number Generator in C

• The rand() function produces the same sequence of numbers unless seeded.
• Use srand(time(NULL)) to initialize the seed with the current time for different outputs on each execution.
• Example:

srand(time(NULL)); // Seeds the generator with the current time

2. Avoid Using rand() for Cryptographic Applications

• rand() is not cryptographically secure.
• Use specialized libraries like OpenSSL or libsodium for security-sensitive applications.
• Example (Using OpenSSL for secure random bytes):

#include <openssl/rand.h>
unsigned char buffer[16];
RAND_bytes(buffer, sizeof(buffer));

3. Use Modulo Carefully When Generating a Range

• The common approach (rand() % (max - min + 1)) + min can introduce bias.
• Prefer floating-point scaling for better uniformity.
• Example:

int randomInRange = min + (int)((double)rand() / (RAND_MAX + 1) * (max - min + 1));

4. Use RAND_MAX for Normalization

• RAND_MAX is the maximum value rand() can return (often 32767).
• Normalize values between 0 and 1 for more predictable results.
• Example:

double randomValue = (double)rand() / RAND_MAX;

5. Be Aware of Thread Safety Issues

• rand() is not thread-safe.
• Use rand_r() (on some systems) or better alternatives like mt19937 for multi-threaded programs.

6. Prefer Mersenne Twister for High-Quality Random Numbers

• rand() has known limitations in randomness distribution.
• The Mersenne Twister (mt19937) is a better alternative with a longer period and better randomness.
• Example:

#include <random>
std::mt19937 rng(time(NULL));
int randomNum = rng() % 100;

7. Use Different Seeds for Multiple Runs

If running a simulation multiple times, ensure that different seeds are used for each run to avoid identical outputs.

8. Avoid Over-Seeding in Loops

• Calling srand(time(NULL)) inside a loop can result in the same values being generated in quick iterations.
• Seed once at the beginning of the program instead.

Conclusion

The random number generator in C is a powerful tool when used correctly. By understanding rand(), srand(), and how to scale values, you can generate numbers for various applications efficiently. Always follow best practices and avoid common pitfalls to ensure better randomness.

Now you know how to use the random number generator in C effectively. Try the code snippets and see the randomness in action.

Take a Free C Programming Quiz

Answer quick questions and assess your C programming knowledge

FREE COURSES

Start Learning For Free

Slide 1 of 5

Data Structures & Algorithm

35k+ learners

50 hrs of learning

View ProgramEnroll Now

Analyzing Patterns in Data and Storytelling

41k+ learners

6 hrs of learning

View ProgramEnroll Now

Learn Basic Python Programming

43k+ learners

5 hrs of learning

View ProgramEnroll Now

JavaScript Basics from Scratch

41k+ learners

19 hrs of learning

View ProgramEnroll Now

Introduction to Data Analysis using Excel

99k+ learners

9 hrs of learning

View ProgramEnroll Now

Explore All Free Courses