Deduzione automatica del tipo: auto

1. Introduzione a auto

Quando scrivi i primi programmi, sembra che i tipi siano solo una «formalità obbligatoria»: ok, ho scritto int, ok, ho scritto double. Ma più codice scrivi, più spesso ti trovi nella situazione in cui il tipo è ovvio dalla parte destra, e scriverlo a mano è come riscrivere i dati del passaporto in ogni riga. auto è stato creato per ridurre questo «rumore» e permettere al compilatore di fare per noi il lavoro semplice — dedurre il tipo dall'inizializzatore.

C'è però un punto sottile: auto non è una «magia che rende il codice intelligente». Al contrario: auto fissa onestamente ciò che hai scritto a destra. Se a destra risulta un int, avrai un int. Anche se in cuor tuo volevi un double. Quindi auto è un buon servitore, ma un pessimo psicoterapeuta: non indovina le intenzioni, esegue le istruzioni.

Idea principale: auto = «deduci il tipo dalla parte destra»

È importante partire da un modello il più semplice possibile, senza parole paurose o filosofia. auto significa: «Compilatore, guarda l'espressione a destra di = e crea la variabile dello stesso tipo». Quindi auto funziona solo dove c'è un inizializzatore. Ha senso: se a destra non c'è nulla, il compilatore non ha da cosa dedurre. Quindi auto è sempre relativo a dichiarazione + inizializzazione nello stesso punto.

Vediamo l'esempio più basilare:

#include <iostream>

int main() {
    auto x = 10;     // x ha tipo int
    auto y = 10.0;   // y ha tipo double

    std::cout << x << ' ' << y << '\n'; // 10 10
}

Il senso non è memorizzare che «10 — è un int». Il senso è che auto è molto letterale: legge la parte destra.

Un altro punto importante: il tipo viene dedotto una sola volta — alla dichiarazione. Dopo di ciò il tipo della variabile non cambia.

#include <iostream>

int main() {
    auto count = 3;   // int
    count = 7;        // ok

    std::cout << count << '\n'; // 7
}

Anche se poi assegni qualcosa di «diverso per natura», il tipo della variabile non cambierà. In C++ la variabile non è un camaleonte.

2. auto non si può usare senza valore iniziale

I principianti spesso vogliono fare: «dichiaro ora, assegno dopo». A volte è comodo, ma con auto non è possibile. E, ad essere onesti, è una restrizione utile: auto ti obbliga a dare un valore iniziale alla variabile, riducendo la possibilità di dimenticare l'inizializzazione.

Non si può fare così:

#include <iostream>

int main() {
    auto value; // errore di compilazione: manca l'inizializzatore
    auto value = 0;

    std::cout << value << '\n'; // 0
}

Se per logica ti serve «dichiarare e poi riempire», o dai un valore di partenza (0, 0.0, ""), oppure scrivi il tipo esplicitamente. A questo livello del corso è una regola sensata: se non puoi inizializzare subito — meglio il tipo esplicito.

3. Trappola №1: auto non risolve la divisione intera

Segue un punto in cui molti percepiscono per la prima volta che il compilatore non è telepatico. Nelle lezioni precedenti abbiamo detto: se dividiamo int / int, otteniamo int, la parte frazionaria viene scartata. Bene, auto non cura questo. Anzi: auto rende il problema meno evidente, perché il tipo non è scritto esplicitamente.

Confrontiamo due varianti:

#include <iostream>

int main() {
    auto a = 1 / 2;    // int, risultato 0
    auto b = 1 / 2.0;  // double, risultato 0.5

    std::cout << a << ' ' << b << '\n'; // 0 0.5
}

Perché succede? Perché 1 / 2 è un'espressione composta da due letterali interi, quindi la divisione è intera e il risultato è l'intero 0. auto dice onestamente: «Ah, a destra c'è un'espressione intera, quindi a sinistra ci sarà un intero».

Se stai scrivendo un programma e vuoi la media, questa trappola si presenta spesso:

#include <iostream>

int main() {
    int sum = 5;
    int count = 2;

    auto avg1 = sum / count;  // int, sarà 2
    auto avg2 = sum / 2.0;    // double, sarà 2.5

    std::cout << avg1 << ' ' << avg2 << '\n'; // 2 2.5
}

Qui auto non è colpevole. È colpevole l'espressione a destra. auto si limita a renderlo più «silenzioso»: non vedi il tipo se non ci pensi.

4. Trappola №2: perdita di dati durante un assegnamento

C'è un'altra illusione tipica: «dato che è auto, sarà più prudente». No. Se la variabile è diventata int, tutte le regole normali di assegnamento continuano a valere. Per esempio, assegnare un double a un int perderà la parte frazionaria (ne abbiamo parlato nel tema sulle conversioni implicite).

#include <iostream>

int main() {
    auto x = 0;   // x è int
    x = 2.9;      // assegniamo double a int, la parte frazionaria viene persa

    std::cout << x << '\n'; // 2
}

È un punto psicologico molto importante: auto non è «tipo a seconda della situazione», ma «tipo una volta per sempre, dedotto alla dichiarazione». Quindi auto non elimina la necessità di pensare ai tipi — sposta semplicemente l'attenzione dalla parte sinistra alla parte destra della riga.

5. Quando auto migliora il codice

Per evitare che auto sembrI una «strana trovata del linguaggio», incorporiamolo in un piccolo frammento di programma che avremmo potuto scrivere anche prima. Immaginiamo un semplice tracker di spese da console: inseriamo il budget giornaliero e le spese effettive, e stampiamo il resto e la percentuale spesa.

Prima — il più diretto possibile, senza auto:

#include <iostream>

int main() {
    double budget = 0.0;
    double spent = 0.0;

    std::cin >> budget >> spent;

    double left = budget - spent;
    std::cout << left << '\n';
}

Il codice funziona, ma nota: left è semplicemente il risultato dell'espressione budget - spent. Abbiamo ripetuto il tipo double, anche se è ovvio dall'espressione a destra (ci sono due double, quindi il risultato è double). Qui auto è un modo elegante per rimuovere la «duplicazione di significato»:

#include <iostream>

int main() {
    double budget = 0.0;
    double spent = 0.0;

    std::cin >> budget >> spent;

    auto left = budget - spent; // left sarà double
    std::cout << left << '\n';
}

Perché questo è meglio? Perché il tipo di left non è così importante quanto il significato della variabile: «resto di soldi». Non stiamo nascondendo informazioni importanti: budget e spese sono esplicitamente double, e il «resto» eredita logicamente il tipo.

Aggiungiamo ora la percentuale spesa. Qui possiamo cogliere due cose: mostrare dove auto è comodo e dove è pericoloso.

#include <iostream>

int main() {
    double budget = 0.0;
    double spent = 0.0;

    std::cin >> budget >> spent;

    auto left = budget - spent;
    auto percent = (spent / budget) * 100.0; // percent sarà double

    std::cout << left << '\n';
    std::cout << percent << '\n';
}

Qui 100.0 è scritto con punto: manteniamo il calcolo nell'ambito dei double. Questo è un caso in cui auto aiuta, ma tu devi comunque costruire l'espressione corretta a destra.

6. Quando auto inizia a danneggiare

Ora la regola più importante della lezione: non usare auto se il tipo è parte del significato dei dati.

Per esempio, immagina la variabile days. I giorni sono una quantità, tipicamente intera. Se scrivi auto days = 30; tecnicamente va bene: sarà un int. Ma il fatto che «giorni = intero» non è fissato esplicitamente, e un principiante (o tu tra una settimana) potrebbe cominciare a considerarlo come «qualche numero». Poi comparirà una divisione, percentuali, frazioni — e la logica si sfalderà.

Confronta la leggibilità:

#include <iostream>

int main() {
    int days = 30;       // esplicito: numero intero di giorni
    double price = 9.99; // esplicito: il prezzo può essere frazionario

    std::cout << days << ' ' << price << '\n'; // 30 9.99
}

E la variante «tutto auto»:

#include <iostream>

int main() {
    auto days = 30;    // sì, è int, ma bisogna "indovinarlo"
    auto price = 9.99; // sì, è double

    std::cout << days << ' ' << price << '\n'; // 30 9.99
}

In un piccolo programma la differenza è minima. Ma nel codice reale «tutto auto» si trasforma rapidamente in uno stile: «non voglio pensare ai tipi affatto». C++ è un linguaggio che di solito non supporta questo atteggiamento e risponde con trasformazioni inattese.

Buona abitudine a questo livello: se una variabile è «dati in ingresso» o il «nucleo del significato», scrivi il tipo esplicitamente. Se la variabile è il risultato di un calcolo a partire da variabili già tipizzate, auto è spesso opportuno.

7. Promemoria: dove auto è appropriato e dove serve il tipo esplicito

Nella pratica non serve fede, ma criteri semplici. Di seguito una tabella compatta da tenere a mente come buona norma (non una legge, ma un buon orientamento).

Nota: la tabella non dice che «auto è cattivo». Dice che «auto è uno strumento, e ha una sua zona di comfort».

Mini‑trucco per l'auto‑controllo: far "parlare" il programma

Quando usi auto, spesso vuoi essere sicuro che i calcoli vadano come previsto. A questo livello del corso lo strumento diagnostico migliore è il più onesto: std::cout. Non cercare di «indovinare a occhio» — stampa il valore e confrontalo con l'atteso.

Per esempio, sospetti che la divisione sia diventata intera. Fai un piccolo test:

#include <iostream>

int main() {
    auto a = 7 / 2;
    auto b = 7 / 2.0;

    std::cout << a << '\n'; // 3
    std::cout << b << '\n'; // 3.5
}

Oppure dubiti che la parte frazionaria sia stata persa nell'assegnamento:

#include <iostream>

int main() {
    auto x = 0; // int
    x = 19.99;

    std::cout << x << '\n'; // 19
}

Sì, sembra un po' «da principianti». Ma è un'ottima abitudine: prima ottieni la prevedibilità, poi curi l'eleganza. In programmazione spesso funziona meglio così.

Esempio: «budget giornaliero» con auto usato con giudizio

Per collegare tutto in un frammento coerente, costruiremo un piccolo pezzo di programma dove i tipi non sono nascosti e auto è usato dove riduce davvero il rumore. Usiamo cose che già sappiamo: input, output, if, aritmetica.

#include <iostream>

int main() {
    double budget = 0.0;
    double spent = 0.0;

    std::cout << "Enter budget and spent: ";
    std::cin >> budget >> spent;

    auto left = budget - spent;
    auto percent = (spent / budget) * 100.0;

    if (left < 0.0) {
        std::cout << "Over budget by " << (-left) << '\n';
    } else {
        std::cout << "Left: " << left << '\n';
    }

    std::cout << "Spent percent: " << percent << '\n';
}

Nota che non abbiamo «riempito» il programma di auto. Le variabili di input (budget, spent) hanno tipo esplicito perché sono dati di significato. Le variabili derivate (left, percent) usano auto perché il loro tipo segue naturalmente dalle espressioni e per noi è più importante il loro significato.

8. Errori tipici con auto

Errore №1: usare auto «al posto dei tipi in generale».
Questo spesso parte da una buona intenzione: «voglio scrivere meno». Ma finisce con il codice che diventa un rebus, dove tutte le variabili appaiono ugualmente misteriose. Se la variabile è una parte importante del modello dati (budget, età, numero di giorni), il tipo esplicito rende il codice più onesto e più facile da leggere.

Errore №2: non accorgersi che auto ha fissato l'aritmetica intera.
Una costruzione come auto avg = sum / count; sembra «riguardare la media», ma se sum e count sono interi, anche avg sarà intero. Non è un bug del compilatore né una «caratteristica speciale di auto», è la diretta conseguenza dell'espressione a destra. Se ti aspetti una frazione, assicurati che compaia un double nell'espressione.

Errore №3: cercare di dichiarare auto senza inizializzatore.
A volte si vuole «creare la variabile ora e riempirla dopo». Con auto non è possibile, perché il compilatore non è un sensitivo. Questa restrizione è utile: ti spinge o a dare un valore iniziale chiaro, o a scrivere il tipo esplicito se non sei pronto a fissare il valore subito.

Errore №4: pensare che auto «cambi il tipo» con assegnamenti successivi.
auto deduce il tipo una volta. Dopo di che la variabile vive come ogni altra variabile di quel tipo. Se scrivi auto x = 0; allora è int, e assegnare x = 2.9; porterà perdita della parte frazionaria. Il tipo non «si aggiorna» a double, anche se lo vorresti.

Errore №5: usare auto dove il tipo è un avvertimento sul significato.
Per esempio, bool come flag di stato, o char come singolo carattere, o double come grandezza frazionaria. Un tipo esplicito qui funziona come un mini‑commento. Se lo sostituisci con auto, il commento scompare e il lettore deve «indovinare dalla parte destra» cosa intendevi.