How to Generate a Random Integer in C

By the end of this page, you will understand how C generates pseudo-random integers using the standard library, how rand() and srand() work together, how to limit values to a range, and what common mistakes to avoid. You will also see when the standard approach is good enough and when stronger randomness is needed.

C includes a standard library function called rand() for generating pseudo-random integers. It is declared in stdlib.h.

#include <stdlib.h>

rand() does not produce truly random values. It produces a sequence of numbers that looks random, based on an internal starting value called a seed.

To choose that starting point, you usually call srand() once near the beginning of the program:

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

srand(time(NULL));

Why this matters:

• If you never call srand(), many C implementations will produce the same sequence every time your program runs.
• If you seed with the current time, the sequence will usually differ from run to run.
• This is useful for games, simulations, simple shuffling, and basic test data.

Important limitation:

• rand() is fine for simple use cases.
• It is not suitable for security-sensitive tasks like passwords, tokens, or cryptographic keys.

The value returned by rand() is between 0 and RAND_MAX inclusive.

int n = rand();

If you want a number in a smaller range, a common beginner pattern is:

int n = rand() % 10;   // 0 to 9

This works for many simple programs, but it can introduce slight bias in some cases because % does not always distribute values perfectly evenly across the target range.

Think of rand() like a machine that spits out numbered tickets.

• The machine always follows a fixed internal pattern.
• The seed is where the machine starts in that pattern.
• If you start from the same seed, you get the same ticket sequence.
• If you start from a different seed, you get a different-looking sequence.

So srand() chooses where to begin, and rand() gives you the next value each time you call it.

A useful way to remember it:

• srand(...) = set the starting point
• rand() = get the next pseudo-random number

Basic syntax

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

int main(void) {
    srand(time(NULL));

    int value = rand();
    printf("Random value: %d\n", value);

    return 0;
}

What this does

• #include <stdlib.h> gives access to rand() and srand().
• #include <time.h> gives access to time().
• srand(time(NULL)) seeds the generator once.
• rand() returns a pseudo-random integer.

Random integer in a range

To get a number from 0 to 9:

Consider this program:

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

int main(void) {
    srand(time(NULL));

    int n = (rand() % 6) + 1;
    printf("Dice roll: %d\n", n);

    return 0;
}

Here is what happens step by step:

1. The program includes the needed headers.

   • stdio.h for printf()
   • stdlib.h for rand() and srand()
   • time.h for time()

2. srand(time(NULL)); runs.

   • returns the current time as a number.

rand() is commonly used in small or non-security-critical programs such as:

• Games: dice rolls, enemy behavior, random loot, spawning positions
• Simulations: coin flips, random events, simple Monte Carlo experiments
• Test data generation: creating sample scores, IDs, or mock sensor values
• Shuffling basic data: randomizing order in simple classroom exercises
• Simple command-line tools: picking a random item from a list

Examples:

• A quiz app picks a random question.
• A board game program simulates rolling two dice.
• A script generates random temperatures between 18 and 30.

For these uses, pseudo-randomness is usually acceptable.

For security-related tasks, such as:

• password generation
• session tokens
• API keys
• cryptographic secrets

rand() should not be used.

In real C codebases, developers often use rand() in a few predictable patterns.

Seed once at program startup

A common pattern is to seed the generator once in main():

int main(void) {
    srand(time(NULL));
    /* rest of program */
}

Calling srand() repeatedly is usually a mistake.

Helper function for a range

Developers often wrap the range logic in a helper function:

int random_in_range(int min, int max) {
    return (rand() % (max - min + 1)) + min;
}

This makes code easier to read:

int hp = random_in_range(50, 100);

Validation with guard clauses

In real projects, functions often validate input first:

  {
     (min > max) {
         ;
    }
     (rand() % (max - min + )) + min;
}

1. Forgetting to include the right headers

Broken code:

int x = rand();

Fix:

#include <stdlib.h>

If you use time(), also include:

#include <time.h>

2. Never calling srand()

Broken idea:

int main(void) {
    printf("%d\n", rand());
    return 0;
}

This may produce the same sequence each run.

Fix:

srand(time(NULL));

3. Calling srand() every time you need a number

Broken code:

Quick reference

Include headers

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

Seed once

srand(time(NULL));

Get a pseudo-random integer

int x = rand();

• Range: 0 to RAND_MAX

Get a number from 0 to n - 1

int x = rand() % n;

Get a number from min to max inclusive

int x = rand() % (max - min + 1) + min;

Repeatable sequence for testing

Does C have a built-in function for random integers?

Yes. C provides rand() in stdlib.h for pseudo-random integers.

What is the difference between rand() and srand() in C?

rand() returns the next pseudo-random number. srand() sets the seed that determines the sequence.

Why do I need srand(time(NULL))?

Without seeding, many programs produce the same sequence each run. Using the current time usually changes the sequence.

How do I generate a random number in a specific range in C?

Use:

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

This gives a value from min to max inclusive.

Is rand() truly random?

No. It is pseudo-random, meaning it follows a deterministic algorithm based on a seed.

Can I use rand() for passwords or tokens?

No. rand() is not secure enough for cryptographic or security-sensitive uses.

• stdlib.h — contains rand(), srand(), and other standard utility functions.
• time.h — provides time() for seeding with the current time.
• pseudo-random numbers — explains why generated values look random but come from a deterministic sequence.
• modulo operator % — used to shrink random values into a target range.
• integer ranges — important for generating values between min and max.
• seeding — the process of choosing the starting point for a pseudo-random sequence.
• RAND_MAX — defines the upper bound of values returned by rand().
• input validation — useful when writing helper functions like random_in_range(min, max).