C Standard Library limits.h

What You’ll Learn

The <limits.h> header defines macros for the minimum and maximum values of integer types—char, short, int, long, and their unsigned variants. It also defines CHAR_BIT, the number of bits in a byte. Use these constants to avoid overflow and write portable code.

Definition and Usage

Every integer type has a finite range. Adding 1 to INT_MAX overflows; subtracting 1 from INT_MIN underflows. The C standard does not fix how many bits an int has—that depends on the compiler and platform—but <limits.h> always tells you the limits for your build.

Macros use a naming pattern: TYPE_MAX and TYPE_MIN for signed types, and UTYPE_MAX for unsigned types (minimum is always 0). Prefixes include SCHAR_, SHRT_, INT_, LONG_, and LLONG_ (C99).

📝 Syntax

Include the header:

#include <limits.h>

Character and byte

• CHAR_BIT — bits in a char (typically 8).
• SCHAR_MIN / SCHAR_MAX — range of signed char.
• UCHAR_MAX — maximum unsigned char (often 255).
• CHAR_MIN / CHAR_MAX — range of plain char (signedness implementation-defined).

Signed integer types

• SHRT_MIN / SHRT_MAX — short.
• INT_MIN / INT_MAX — int.
• LONG_MIN / LONG_MAX — long.
• LLONG_MIN / LLONG_MAX — long long (C99).

Unsigned integer types

• USHRT_MAX, UINT_MAX, ULONG_MAX, ULLONG_MAX.
• Unsigned minimum is always 0 (no UINT_MIN macro).

Typical values (32-bit int platform)

/* Examples only — use macros from limits.h, not literals */
CHAR_BIT     /* often 8 */
SCHAR_MIN    /* often -128 */
SCHAR_MAX    /* often 127 */
UCHAR_MAX    /* often 255 */
INT_MIN      /* often -2147483648 */
INT_MAX      /* often 2147483647 */
UINT_MAX     /* often 4294967295 */

Headers and linking

• #include <limits.h> — macros only, no link flag.
• For fixed-width types, also see <stdint.h> (INT32_MAX, etc.).
• For floating limits, see <float.h>.
• Compile: gcc program.c -std=c11 -o program

Examples Gallery

Compile with gcc file.c -std=c11 -o out. Sample output matches typical GCC on a 64-bit system with 32-bit int and 64-bit long.

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

int main(void) {
    printf("CHAR_BIT = %d\n\n", CHAR_BIT);

    printf("signed char:   %d to %d\n", SCHAR_MIN, SCHAR_MAX);
    printf("unsigned char: 0 to %u\n", UCHAR_MAX);
    printf("short:         %d to %d\n", SHRT_MIN, SHRT_MAX);
    printf("unsigned short:0 to %u\n", USHRT_MAX);
    printf("int:           %d to %d\n", INT_MIN, INT_MAX);
    printf("unsigned int:  0 to %u\n", UINT_MAX);
    printf("long:          %ld to %ld\n", LONG_MIN, LONG_MAX);
    printf("unsigned long: 0 to %lu\n", ULONG_MAX);

    return 0;
}

CHAR_BIT = 8

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

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

int safe_add(int a, int b, int *out) {
    if (b > 0 && a > INT_MAX - b) {
        return -1;  /* overflow */
    }
    if (b < 0 && a < INT_MIN - b) {
        return -1;  /* underflow */
    }
    *out = a + b;
    return 0;
}

int main(void) {
    int result;

    if (safe_add(INT_MAX, 1, &result) != 0) {
        printf("Overflow avoided: INT_MAX + 1 does not fit in int\n");
    } else {
        printf("Result: %d\n", result);
    }

    return 0;
}

Overflow avoided: INT_MAX + 1 does not fit in int

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

int main(void) {
    printf("CHAR_BIT = %d bits per byte\n", CHAR_BIT);
    printf("sizeof(char)  = %zu byte  (%zu bits)\n",
           sizeof(char), sizeof(char) * CHAR_BIT);
    printf("sizeof(short) = %zu bytes (%zu bits)\n",
           sizeof(short), sizeof(short) * CHAR_BIT);
    printf("sizeof(int)   = %zu bytes (%zu bits)\n",
           sizeof(int), sizeof(int) * CHAR_BIT);
    printf("sizeof(long)  = %zu bytes (%zu bits)\n",
           sizeof(long), sizeof(long) * CHAR_BIT);

    return 0;
}

CHAR_BIT = 8 bits per byte
sizeof(char)  = 1 byte  (8 bits)
sizeof(short) = 2 bytes (16 bits)
sizeof(int)   = 4 bytes (32 bits)
sizeof(long)  = 8 bytes (64 bits)

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

int fits_in_int(long value) {
    return value >= INT_MIN && value <= INT_MAX;
}

int main(void) {
    long candidates[] = { 100L, 2147483647L, 3000000000L };

    for (size_t i = 0; i < 3; i++) {
        long v = candidates[i];
        printf("%ld: %s\n", v,
               fits_in_int(v) ? "fits in int" : "too large for int");
    }

    return 0;
}

100: fits in int
2147483647: fits in int
3000000000: too large for int

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

int main(void) {
    printf("limits.h says:\n");
    printf("  INT_MAX  = %d\n", INT_MAX);
    printf("  UINT_MAX = %u\n", UINT_MAX);

    printf("\nsizeof says:\n");
    printf("  int          = %zu bytes\n", sizeof(int));
    printf("  unsigned int = %zu bytes\n", sizeof(unsigned int));

    printf("\nRule of thumb: %zu-byte int holds roughly %d decimal digits.\n",
           sizeof(int), (int)(sizeof(int) * CHAR_BIT * 0.301) + 1);

    return 0;
}

limits.h says:
  INT_MAX  = 2147483647
  UINT_MAX = 4294967295

sizeof says:
  int          = 4 bytes
  unsigned int = 4 bytes

Rule of thumb: 4-byte int holds roughly 10 decimal digits.

🚀 Common Use Cases

• Overflow checks — validate sums, products, and array index math.
• Input validation — ensure parsed numbers fit the target type.
• Buffer sizing — use UCHAR_MAX + 1 (256) for byte tables when char is 8 bits.
• Portable constants — replace magic numbers in algorithms.
• Serialization — pick the narrowest type that fits a value range.
• Embedded systems — confirm int width before porting desktop code.

📝 Notes

• Macro values are implementation-defined—never hard-code 2147483647.
• char may be signed or unsigned; use signed char / unsigned char when sign matters.
• Unsigned overflow wraps modulo UTYPE_MAX + 1; signed overflow is undefined behavior.
• INT_MIN often has no positive counterpart (e.g. -2147483648).
• C99 adds LLONG_* macros for long long.
• For floating-point limits, use <float.h>, not limits.h.

⚡ Optimization

Limit macros compile to constants—zero runtime cost. Choose the smallest type that fits your data (unsigned char for 0–255) to save memory in large arrays. Overflow checks add branches; keep them on untrusted input paths, not every inner-loop increment.

💡 Best Practices