sizeof and limits.h: Asking the Machine Instead of Guessing

Kenji's program works for a year on his laptop. Then it is loaded onto a small chip in a card reader, and every number above 32,767 comes out wrong.

He had not written a bug. He had written down a size, in his head, and taken it with him to a machine that disagreed. This lesson is one habit: ask, do not guess.

sizeof: the operator that answers in bytes

sizeof looks like a function and is not one. It is an operator, built into the language, and the compiler works out its answer before the program ever runs.

sizeof(int)         a TYPE needs the parentheses
sizeof marks        an EXPRESSION does not
sizeof(marks)       also fine, and what most people write

sizeof marks + 1    is (sizeof marks) + 1, which is 5
sizeof (marks + 1)  is the size of the expression, which is 4

So parentheses are required for a type and optional for a variable. The last two lines of that card are a trap worth reading twice.

size_t, and the %zu that goes with it

sizeof does not give back an int. It gives back a size_t, an unsigned type that is wide enough to hold the size of the largest thing the machine can store.

It is 8 bytes on the Playground and on any 64-bit machine, and 2 bytes on a small chip. That is the point of it: it is defined by the machine, not by a number somebody chose.

Because it is unsigned, size_t can never be negative, and subtracting past zero wraps exactly as lesson 2 described.

So print it with %zu, and when you want a plain int for arithmetic, write the cast yourself and mean it.

limits.h and float.h: printed, not copied

Two headers hold every boundary value, already correct for the machine you are on.

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

int main(void)
{
    printf("bits in a byte : %d\n", CHAR_BIT);
    printf("int range      : %d to %d\n", INT_MIN, INT_MAX);
    printf("long long top  : %lld\n", LLONG_MAX);
    printf("float digits   : %d\n", FLT_DIG);
    printf("double digits  : %d\n", DBL_DIG);
    printf("double largest : %e\n", DBL_MAX);
    return 0;
}

bits in a byte : 8
int range      : -2147483648 to 2147483647
long long top  : 9223372036854775807
float digits   : 6
double digits  : 15
double largest : 1.797693e+308

FLT_DIG is 6 and DBL_DIG is 15. Lesson 3 said "about 7" and "about 15 or 16"; these are the numbers the machine will actually stand behind.

So a range you printed is a fact about today's machine. A range you typed from memory is a hope.

long is the one to distrust

Here is a fact you can check for yourself, and it is the reason this whole lesson exists.

On the Playground, which runs 64-bit Linux, sizeof(long) is 8. On a Windows machine with the same processor and the same compiler, it is 4.

Same code, same chip, same GCC. Two answers. Nothing is wrong with either one: the standard promises only that long reaches about plus or minus 2.1 billion, and both machines keep that promise.

Every other size in this module agrees across both: char 1, short 2, int 4, long long 8, float 4, double 8.

So this track writes long long and never long, and the exercise below asks you to print a list of sizes with long deliberately left out.

stdint.h: when the size has to be the same everywhere

Sometimes "at least 4 bytes" is not good enough. A network packet, a file format and a hash all need a value that is exactly 32 bits wide, on every machine, for ever.

<stdint.h> gives you those types, and their names say the width out loud.

These are not new types. They are other names for the ordinary types, chosen per machine so that the width is right. int32_t is int on the Playground.

Printing them takes care, because the underlying type differs by machine. Inside this module, read and print a fixed-width value through a long long and %lld, which is wide enough for all of them.

So use a plain int for ordinary counting, and a fixed-width type when the number of bits is part of the specification.

#include <stdio.h>

int main(void)
{
    int marks = 90;

    printf("sizeof(int)        : %zu\n", sizeof(int));
    printf("sizeof marks       : %zu\n", sizeof marks);
    printf("sizeof marks + 1   : %zu\n", sizeof marks + 1);
    printf("sizeof (marks + 1) : %zu\n", sizeof (marks + 1));
    return 0;
}

sizeof(int)        : 4
sizeof marks       : 4
sizeof marks + 1   : 5
sizeof (marks + 1) : 4

#include <stdio.h>

int main(void)
{
    printf("char      : %zu\n", sizeof(char));
    printf("short     : %zu\n", sizeof(short));
    printf("int       : %zu\n", sizeof(int));
    printf("long long : %zu\n", sizeof(long long));
    printf("float     : %zu\n", sizeof(float));
    printf("double    : %zu\n", sizeof(double));
    printf("size_t    : %zu\n", sizeof(size_t));
    printf("long      : ask your own machine\n");
    return 0;
}

char      : 1
short     : 2
int       : 4
long long : 8
float     : 4
double    : 8
size_t    : 8
long      : ask your own machine

#include <stdio.h>
#include <stdint.h>

int main(void)
{
    uint8_t  version = 4;
    uint16_t port = 443;
    int64_t  timestamp = 1758240000;

    printf("version   : %lld in %zu byte\n", (long long)version, sizeof version);
    printf("port      : %lld in %zu bytes\n", (long long)port, sizeof port);
    printf("timestamp : %lld in %zu bytes\n", (long long)timestamp, sizeof timestamp);
    return 0;
}

version   : 4 in 1 byte
port      : 443 in 2 bytes
timestamp : 1758240000 in 8 bytes

printf("%d\n", sizeof(int));

#include <stdio.h>

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

int marks = 90;
printf("%zu\n", sizeof marks + 1);

long total_bytes = 8;      /* "a long is 8 bytes" */

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

int main(void)
{
    printf("bits: %zu\n", sizeof(int) * 8);
    printf("bits: %zu\n", sizeof(int) * CHAR_BIT);
    return 0;
}

#include <stdio.h>

int main(void)
{
    printf("char: %zu\n", sizeof(char));

    /* Five more lines, same shape. */

    return 0;
}

#include <stdio.h>

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

    /* Multiply by sizeof(double), print with %lld. */

    return 0;
}

#include <stdio.h>

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

    /* Lesson 4: a comparison is a 1 or a 0, and two of them multiplied is "both". */

    return 0;
}

Next is the Problems lesson: ten graded problems over everything in this module, judged against hidden tests.