typeof și auto în C

typeof(expresie) nume;        // același tip ca expresia
typeof_unqual(expresie) nume; // fără const/volatile
auto nume = valoare;          // tipul este dedus din valoare

Ce face typeof și auto

typeof(x) înseamnă „același tip ca x”. Se folosește mai ales în macro, unde nu știi dinainte cu ce tip vor fi apelate: o macro INTERSCHIMBA(a, b) poate declara o variabilă temporară typeof(a) tmp și merge pentru int, double sau pointeri. Expresia din typeof nu este calculată, doar tipul ei contează.

typeof păstrează calificatorii: pentru o variabilă const int, tipul este tot const int. typeof_unqual elimină const și volatile, util când vrei o copie pe care o poți modifica. Ambele existau ca extensii GCC și Clang (__typeof__) și au devenit standard în C23.

Tot în C23, auto declară o variabilă al cărei tip este dedus din inițializare: auto pret = 19.99; face pret de tip double. Spre deosebire de C++, în C auto merge doar pentru variabile cu inițializare, nu pentru tipul returnat de funcții.

Exemple

Exemplul 1: O macro de interschimbare pentru orice tip

typeof(a) dă tipul variabilei temporare, deci aceeași macro funcționează pentru note (int) și pentru prețuri (double). do { ... } while (0) face din macro o singură instrucțiune.

#include <stdio.h>

#define INTERSCHIMBA(a, b) do { \
    typeof(a) tmp_ = (a);       \
    (a) = (b);                  \
    (b) = tmp_;                 \
} while (0)

int main(void) {
    int nota_ana = 7, nota_ion = 10;
    double pret_vechi = 12.5, pret_nou = 9.9;

    INTERSCHIMBA(nota_ana, nota_ion);
    INTERSCHIMBA(pret_vechi, pret_nou);

    printf("Ana: %d, Ion: %d\n", nota_ana, nota_ion);
    printf("vechi: %.2f, nou: %.2f\n", pret_vechi, pret_nou);
    return 0;
}

Rezultat

Ana: 10, Ion: 7
vechi: 9.90, nou: 12.50

Exemplul 2: typeof_unqual: o copie modificabilă a unei constante

LIMITA este const int. O variabilă declarată cu typeof(LIMITA) ar fi tot const și nu s-ar putea modifica; typeof_unqual dă un int obișnuit.

#include <stdio.h>

int main(void) {
    const int LIMITA = 3;
    typeof_unqual(LIMITA) incercari = LIMITA;

    while (incercari > 0) {
        printf("Încercări rămase: %d\n", incercari);
        incercari--;
    }
    printf("sizeof(typeof(LIMITA)) = %zu\n", sizeof(typeof(LIMITA)));
    return 0;
}

Rezultat

Încercări rămase: 3
Încercări rămase: 2
Încercări rămase: 1
sizeof(typeof(LIMITA)) = 4

Exemplul 3: auto deduce tipul din valoare

_Generic arată tipul dedus: 19.99 este double, 3 este int, 'A' este int în C (nu char), iar un literal cu sufixul L este long.

#include <stdio.h>

#define TIP(x) _Generic((x), int: "int", long: "long", double: "double", default: "alt tip")

int main(void) {
    auto pret = 19.99;
    auto bucati = 3;
    auto litera = 'A';
    auto populatie_iasi = 271692L;

    printf("pret:   %s\n", TIP(pret));
    printf("bucati: %s\n", TIP(bucati));
    printf("litera: %s\n", TIP(litera));
    printf("populatie_iasi: %s\n", TIP(populatie_iasi));
    printf("Total: %.2f lei\n", pret * bucati);
    return 0;
}

Rezultat

pret:   double
bucati: int
litera: int
populatie_iasi: long
Total: 59.97 lei

Greșeli frecvente

• Pui în typeof o expresie cu efecte (typeof(i++)) și te aștepți să se execute. Expresia nu este evaluată (în afară de tablourile cu lungime variabilă), deci i nu crește.
• Scrii auto x; fără valoare. În C23 auto are nevoie de inițializare, altfel nu are din ce deduce tipul.
• Folosești auto pentru tablouri: auto note[] = {9, 10}; nu este permis. Declară tipul explicit (int note[] = {9, 10};).

Comenzi înrudite

• Macro cu parametri: Macro care primesc argumente, ca o funcție: textul lor este copiat în locul apelului, cu operatorii # și ## și argumente variabile.
• constexpr: Declară o constantă cu valoare calculată la compilare, cu tip, care poate fi folosită ca dimensiune de tablou sau în static_assert.
• 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).
• const: Marchează o variabilă ca doar pentru citire: compilatorul oprește orice încercare de a o modifica.
• nullptr: Constanta C23 pentru pointerul nul, cu tip propriu (nullptr_t), mai sigură decât NULL sau 0.