C Standard Library stdint.h

What You’ll Learn

On one machine int might be 32 bits; on another it could differ. <stdint.h> (C99) gives you names like int32_t and uint8_t with guaranteed widths—essential for file formats, network protocols, and hardware registers where every byte must match a specification.

Definition and Usage

stdint.h typedefs signed and unsigned integers with explicit bit counts. An int32_t is always exactly 32 bits (when the type exists on the platform). A uint8_t is always an 8-bit unsigned byte.

The header also defines least-width types (smallest type with at least N bits), fast-width types (fastest type with at least N bits), pointer-sized integers (intptr_t), maximum-width integers (intmax_t), and limit macros such as INT32_MAX and UINT8_MAX.

📝 Syntax

Include the header:

#include <stdint.h>

Exact-width integer types (most common)

• int8_t, uint8_t — 8-bit signed / unsigned
• int16_t, uint16_t — 16-bit signed / unsigned
• int32_t, uint32_t — 32-bit signed / unsigned
• int64_t, uint64_t — 64-bit signed / unsigned (if available)

Other typedef families

• int_least16_t, uint_least16_t — at least 16 bits, smallest such type
• int_fast16_t, uint_fast16_t — at least 16 bits, fastest such type
• intptr_t, uintptr_t — hold a pointer value as an integer
• intmax_t, uintmax_t — widest integer types available

Limit macros (examples)

INT8_MIN,   INT8_MAX,   UINT8_MAX
INT16_MIN,  INT16_MAX,  UINT16_MAX
INT32_MIN,  INT32_MAX,  UINT32_MAX
INT64_MIN,  INT64_MAX,  UINT64_MAX

Printing with inttypes.h (recommended)

#include <inttypes.h>   /* includes stdint.h */

int32_t  x = -42;
uint16_t y = 65535;

printf("x = %" PRId32 "\n", x);
printf("y = %" PRIu16 "\n", y);

Headers and linking

• #include <stdint.h> — typedefs and limit macros only; no link flag.
• #include <inttypes.h> — adds PRI* and SCN* macros for printf/scanf.
• C99 or later: gcc program.c -std=c11 -o program.

Examples Gallery

Compile with gcc file.c -std=c11 -o out. Examples 1 and 2 use portable PRI macros from <inttypes.h> instead of plain %d/%u.

#include <stdio.h>
#include <inttypes.h>

int main(void) {
    int32_t  my_int = 42;
    uint16_t my_unsigned = 65535;

    printf("Signed integer:   %" PRId32 "\n", my_int);
    printf("Unsigned integer: %" PRIu16 "\n", my_unsigned);
    printf("sizeof(int32_t)=%zu, sizeof(uint16_t)=%zu\n",
           sizeof(my_int), sizeof(my_unsigned));

    return 0;
}

Signed integer:   42
Unsigned integer: 65535
sizeof(int32_t)=4, sizeof(uint16_t)=2

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

typedef struct {
    uint8_t r;
    uint8_t g;
    uint8_t b;
} Pixel;

int main(void) {
    Pixel orange = { 255, 165, 0 };

    printf("RGB pixel: (%u, %u, %u)\n",
           orange.r, orange.g, orange.b);
    printf("Pixel size: %zu bytes\n", sizeof(Pixel));

    return 0;
}

RGB pixel: (255, 165, 0)
Pixel size: 3 bytes

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

bool fits_int32(long value) {
    return value >= INT32_MIN && value <= INT32_MAX;
}

int main(void) {
    long candidates[] = { -2147483648L, 0L, 2147483647L, 3000000000L };
    size_t i;

    printf("INT32_MIN = %ld\n", (long)INT32_MIN);
    printf("INT32_MAX = %ld\n", (long)INT32_MAX);

    for (i = 0; i < 4; i++) {
        printf("%ld -> %s\n", candidates[i],
               fits_int32(candidates[i]) ? "fits" : "overflow");
    }

    return 0;
}

INT32_MIN = -2147483648
INT32_MAX = 2147483647
-2147483648 -> fits
0 -> fits
2147483647 -> fits
3000000000 -> overflow

#include <stdio.h>
#include <inttypes.h>

int main(void) {
    uint64_t bytes = 5000000000ULL;

    printf("File size: %" PRIu64 " bytes\n", bytes);
    printf("In hex:    0x%" PRIx64 "\n", bytes);

    return 0;
}

File size: 5000000000 bytes
In hex:    0x12a05f200

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

typedef struct {
    uint32_t magic;      /* 'CFUN' as number */
    uint16_t version;
    uint16_t flags;
    uint32_t payload_size;
} FileHeader;

int main(void) {
    FileHeader hdr = {
        .magic = 0x4346554Eu,  /* CFUN in ASCII hex */
        .version = 1,
        .flags = 0,
        .payload_size = 1024
    };

    printf("magic=0x%08" PRIx32 ", version=%" PRIu16
           ", payload=%" PRIu32 " bytes\n",
           hdr.magic, hdr.version, hdr.payload_size);
    printf("Header size: %zu bytes\n", sizeof(FileHeader));

    return 0;
}

magic=0x4346554e, version=1, payload=1024 bytes
Header size: 12 bytes

🚀 Common Use Cases

• Binary file formats — headers and records with fixed field sizes.
• Network protocols — TCP/IP fields, packet lengths, port numbers.
• Embedded systems — hardware registers mapped to uint32_t.
• Graphics and audio — pixels (uint8_t), samples (int16_t).
• Cross-platform libraries — public APIs that must behave identically everywhere.
• Cryptography and hashes — byte arrays as uint8_t buffers.

📝 Notes

• C99 feature—compile with -std=c99 or newer.
• Exact-width types exist only if the implementation supports that width.
• Use <inttypes.h> for printf/scanf format macros (PRId32, SCNd32, etc.).
• Fixed-width structs may still have padding—stdint fixes member widths, not overall struct layout.
• Endianness (byte order) is not handled by stdint.h—serialize explicitly for network/disk.
• int is still appropriate for most application logic; do not replace every int with int32_t without reason.

⚡ Optimization

int_fast16_t may be faster than int16_t on some CPUs because the CPU prefers native word size. For hot loops, profiling can justify fast types. For on-wire layout, always use exact-width types (uint16_t), not fast types. Typedefs have zero runtime overhead—they are aliases checked at compile time.

💡 Best Practices