stdint.h și limits.h în C

#include <stdint.h>
int8_t, int16_t, int32_t, int64_t
uint8_t, uint16_t, uint32_t, uint64_t
#include <limits.h>
INT_MIN, INT_MAX, UINT_MAX, CHAR_BIT, LONG_MAX

Ce face stdint.h și limits.h

stdint.h (C99) definește tipuri întregi cu un număr exact de biți: int8_t, int16_t, int32_t, int64_t și variantele fără semn uint8_t … uint64_t. Le folosești când dimensiunea contează: formate de fișiere, protocoale de rețea, registre hardware.

limits.h (C89) dă limitele tipurilor de bază: INT_MIN, INT_MAX, UINT_MAX, LONG_MAX, CHAR_BIT (biți într-un octet, aproape mereu 8). stdint.h are și ea INT32_MAX, UINT8_MAX etc.

Pentru afișarea acestor tipuri cu printf, inttypes.h oferă macro-uri precum PRId64 și PRIu32, care se lipesc de textul formatului.

Exemple

Exemplul 1: Limitele lui int

Pe sistemele actuale, int are 32 de biți, deci merge de la -2147483648 la 2147483647.

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

int main(void) {
    printf("biți într-un octet: %d\n", CHAR_BIT);
    printf("INT_MIN  = %d\n", INT_MIN);
    printf("INT_MAX  = %d\n", INT_MAX);
    printf("UINT_MAX = %u\n", UINT_MAX);
    printf("LLONG_MAX = %lld\n", LLONG_MAX);
    return 0;
}

Rezultat

biți într-un octet: 8
INT_MIN  = -2147483648
INT_MAX  = 2147483647
UINT_MAX = 4294967295
LLONG_MAX = 9223372036854775807

Exemplul 2: Tipuri cu dimensiune exactă și PRId64

PRId64 se transformă în textul potrivit pentru int64_t pe sistemul curent (de exemplu "lld"), deci formatul rămâne corect peste tot.

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

int main(void) {
    int64_t populatie_ro = 19051562;
    uint8_t nota = 10;
    int32_t temperatura = -7;
    printf("Populație: %" PRId64 "\n", populatie_ro);
    printf("Notă: %" PRIu8 ", temperatură: %" PRId32 " °C\n", nota, temperatura);
    printf("uint8_t ocupă %zu octet, int64_t ocupă %zu octeți\n", sizeof nota, sizeof populatie_ro);
    return 0;
}

Rezultat

Populație: 19051562
Notă: 10, temperatură: -7 °C
uint8_t ocupă 1 octet, int64_t ocupă 8 octeți

Exemplul 3: Un tip fără semn trece de la maxim la 0

Pentru tipurile fără semn, depășirea este bine definită: valoarea „se învârte” (modulo 2ⁿ). Pentru tipurile cu semn, depășirea este comportament nedefinit.

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

int main(void) {
    uint8_t contor = 254;
    for (int i = 0; i < 4; i++) {
        printf("%u ", contor);
        contor++;
    }
    printf("\n");
    return 0;
}

Rezultat

254 255 0 1

Greșeli frecvente

• Afișezi un int64_t cu %ld. Merge pe unele sisteme și dă avertisment sau rezultat greșit pe altele; folosește PRId64.
• Aduni la INT_MAX și verifici apoi dacă rezultatul e negativ. Depășirea unui întreg cu semn este comportament nedefinit; verifică înainte (a > INT_MAX - b) sau folosește ckd_add din C23.
• Compari un int negativ cu un unsigned: -1 < 1u este fals, pentru că -1 este convertit la un număr fără semn foarte mare.

Comenzi înrudite

• Tipuri de date (int, char, double): Tipurile de bază din C: întregi (char, short, int, long, long long), cu sau fără semn, și numere reale (float, double).
• sizeof: Operatorul care spune câți octeți ocupă un tip sau o variabilă; calculat de compilator, rezultatul are tipul size_t.
• Specificatori de format (%d, %f, %s): Ce înseamnă %d, %u, %f, %e, %s, %c, %x, %zu și cum controlezi lățimea, zecimalele și alinierea în printf.
• ckd_add, ckd_sub, ckd_mul: Adunare, scădere și înmulțire cu verificarea depășirii: funcțiile din stdckdint.h spun dacă rezultatul a încăput în tip.
• Comportament nedefinit (undefined behavior): Situațiile pentru care standardul C nu spune ce se întâmplă: programul poate merge, poate da rezultate greșite sau se poate opri.