Integer Types, Their Ranges, and Overflow

Kenji builds a step counter. It works for two years, and then one user's total goes negative overnight. That user had walked past 2,147,483,647 steps.

Nothing was broken. The box was full, and C did what a full box does. This lesson is about where the top of a box is, and what is on the other side of it.

The integer family

An integer is a whole number, with no decimal point. C gives you five sizes of box, each in a signed and an unsigned flavour.

Read the heading of that table again. It says "on the Playground", and that is not politeness.

What the standard promises, and what it does not

The C standard sets minimum ranges, not exact sizes. It promises this and no more.

• char is 1 byte, always, by definition. A byte is at least 8 bits.
• short and int reach at least -32,767 to 32,767.
• long reaches at least about plus or minus 2.1 billion.
• long long reaches at least about plus or minus 9.2 quintillion.
• Each type in that list is at least as wide as the one before it.

So int is 4 bytes on every desktop and phone you will meet. It is 2 bytes on small chips inside washing machines and car dashboards, and those chips run C too.

long is the one to distrust. It is 8 bytes on Linux and macOS, and 4 bytes on Windows, on the same processor. Lesson 5 shows you how to ask instead of guessing.

So the honest habit is: int for ordinary counting, long long when a number might pass 2 billion. And never write a size into your head as a fact.

Signed and unsigned: the same bits, two readings

Every integer type comes in two flavours. A signed type spends one bit on the sign, so half its range is negative. An unsigned type has no negatives and spends that bit on size instead, which doubles the top.

#include <stdio.h>

int main(void)
{
    int temperature = -12;                 /* signed by default */
    unsigned int student_count = 350;      /* never negative, so unsigned fits */

    printf("temperature   : %d\n", temperature);
    printf("student count : %u\n", student_count);
    return 0;
}

temperature   : -12
student count : 350

Plain int means signed int. You write unsigned when you want the other reading.

Use unsigned when a negative value would be meaningless: a count of people, a size in bytes, a position in a list. Then read the next two sections before you trust it.

The limits live in a header

You do not memorise the ranges. You print them, from <limits.h>, on the machine you are actually running on.

#include <stdio.h>
#include <limits.h>

int main(void)
{
    printf("signed char : %d to %d\n", SCHAR_MIN, SCHAR_MAX);
    printf("short       : %d to %d\n", SHRT_MIN, SHRT_MAX);
    printf("int         : %d to %d\n", INT_MIN, INT_MAX);
    printf("long long   : %lld to %lld\n", LLONG_MIN, LLONG_MAX);
    printf("unsigned int: 0 to %u\n", UINT_MAX);
    return 0;
}

signed char : -128 to 127
short       : -32768 to 32767
int         : -2147483648 to 2147483647
long long   : -9223372036854775808 to 9223372036854775807
unsigned int: 0 to 4294967295

long is missing from that list on purpose. Its answer is 8 on the Playground and 4 on a Windows machine. A printed list of ranges cannot contain it and stay true everywhere.

So the header is the answer to "how big is it", and lesson 5 turns that into a habit.

Unsigned wraps, and the standard says so

Unsigned arithmetic is defined to wrap, like a car odometer rolling from 999999 back to 000000. This is a rule, not an accident.

#include <stdio.h>

int main(void)
{
    unsigned int stock = 0;
    printf("stock       : %u\n", stock);

    stock = stock - 1;
    printf("stock - 1   : %u\n", stock);

    unsigned int big = 4294967295u;
    printf("big + 1     : %u\n", big + 1u);
    return 0;
}

stock       : 0
stock - 1   : 4294967295
big + 1     : 0

Nothing went wrong there. Every one of those three numbers is promised by the standard, on every machine, for ever.

That is also why it bites. A shop that has 0 items in stock and sells 1 now has four billion items, and no message was printed anywhere.

So unsigned is right for a value that genuinely cannot be negative, and wrong for a value you are going to subtract from.

Signed overflow is undefined, which is worse than wrong

Push a signed integer past its top and the C standard stops describing your program. Not "gives a strange number". Stops describing it.

That phrase is undefined behaviour, and it means the compiler is allowed to assume the situation never happens. It then builds your program on that assumption.

On the machine we ran this on, the value wrapped to the bottom of the range, which is what most people expect. The same program also answered a question about itself incorrectly, in the same run, because the compiler had assumed the wrap away.

Both of those are allowed. Neither is a bug in the compiler. The bug is in the program that overflowed.

So the habit is: when a calculation might pass about 2 billion, use long long before it does, not after.

Suffixes: telling the compiler what kind of number you wrote

A plain number in your code, like 42, is an int. Add a letter and you change what it is.

42        int                    printf("%d",   42)
42u       unsigned int           printf("%u",   42u)
42L       long                   printf("%ld",  42L)
42LL      long long              printf("%lld", 42LL)
42ULL     unsigned long long     printf("%llu", 42ULL)

So the suffix is how you widen a calculation before it starts, and the specifier is how you read the answer out.

#include <stdio.h>
#include <limits.h>

int main(void)
{
    int top = INT_MAX;
    long long roomy = (long long)INT_MAX + 1;

    printf("int can reach   : %d\n", top);
    printf("long long holds : %lld\n", roomy);
    return 0;
}

int can reach   : 2147483647
long long holds : 2147483648

#include <stdio.h>

int main(void)
{
    unsigned int stock = 0;
    unsigned int big = 4294967295u;

    printf("0 - 1 as unsigned : %u\n", stock - 1u);
    printf("top + 1           : %u\n", big + 1u);
    printf("top + 2           : %u\n", big + 2u);
    return 0;
}

0 - 1 as unsigned : 4294967295
top + 1           : 0
top + 2           : 1

#include <stdio.h>

int main(void)
{
    int steps_per_day = 0;
    int days = 0;
    scanf("%d %d", &steps_per_day, &days);

    int as_int = steps_per_day * days;
    long long as_long_long = (long long)steps_per_day * days;

    printf("as int       : %d\n", as_int);
    printf("as long long : %lld\n", as_long_long);
    return 0;
}

as int       : -294967296
as long long : 4000000000

int big = 3000000000;
printf("%d\n", big);

long long big = 5000000000LL;
printf("%d\n", big);

int x;
scanf("%d", &x);
printf("did it overflow? %d\n", x + 1 < x);

int a = -1;
unsigned int b = 1;
printf("%d\n", a < b);

#include <stdio.h>

int main(void)
{
    unsigned int stock = 3;
    unsigned int order = 5;

    printf("enough? %d\n", stock - order >= 0);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);

    /* The inputs fit in an int. The answer does not. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    long long s = 0;
    scanf("%lld", &s);

    /* 86400 seconds in a day, 3600 in an hour, 60 in a minute. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    unsigned int a = 0;
    unsigned int b = 0;
    scanf("%u %u", &a, &b);

    printf("%u\n", a - b);
    printf("%lld\n", (long long)a - (long long)b);
    return 0;
}

#include <stdio.h>

int main(void)
{
    long long id = 0;
    scanf("%lld", &id);

    long long top = id / 1000000000LL;
    long long rest = 0;       /* what is left when the top is taken away */

    printf("%lld\n", top);
    printf("%lld\n", rest);
    return 0;
}

Next are the numbers with a decimal point, where the surprise is not the size of the box but the fact that 0.1 was never quite 0.1.