auto in C++: la deduzione del tipo spiegata con esempi

Lascia scegliere il tipo al compilatore

Nella pagina precedente hai visto che ogni variabile C++ ha un tipo fisso: int, double, std::string e così via. Scrivere il tipo a mano va bene per int count = 0;, ma diventa rumoroso quando i tipi si allungano. La parola chiave auto (da C++11 in poi) permette al compilatore di dedurre il tipo dal valore che assegni, così scrivi il valore una volta e lasci che il compilatore completi il resto.

#include <iostream>
using namespace std;

int main() {
    auto count = 0;        // int
    auto price = 3.99;     // double
    auto letter = 'A';     // char
    auto greeting = "hi";  // const char*

    cout << count << " " << price << " " << letter << " " << greeting << "\n";
    return 0;
}

L'idea chiave: auto non è tipizzazione dinamica. Ogni variabile ha comunque un solo tipo concreto, fissato in fase di compilazione. auto ti risparmia solo di doverlo scrivere.

Perché auto vale la pena

Per tipi brevi e ovvi, auto count = 0; e int count = 0; sono ugualmente leggibili. Dove auto ripaga davvero è con i nomi di tipo lunghi e ripetitivi, quelli che ottieni dai contenitori e dagli iteratori della libreria standard.

Confronta la versione prolissa con quella con auto:

// Senza auto: in pratica il tipo si scrive due volte
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// Con auto: il compilatore conosce già il tipo
auto it = scores.begin();

Entrambe dichiarano esattamente lo stesso tipo di iteratore. La seconda è più facile da leggere e non smetterà di essere corretta se in seguito cambi scores con un contenitore diverso.

Eccola in un programma completo:

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<pair<string, int>> scores = {{"Ada", 90}, {"Boris", 85}};

    for (auto it = scores.begin(); it != scores.end(); ++it) {
        cout << it->first << ": " << it->second << "\n";
    }
    return 0;
}

auto nei cicli for basati su range

Il posto in cui incontrerai auto più spesso è il ciclo for basato su range. Non vorrai quasi mai scrivere a mano il tipo degli elementi, e il modo in cui scrivi auto decide se ottieni una copia o un riferimento.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<string> names = {"Ada", "Boris", "Rosa"};

    // const auto&: sola lettura, nessuna copia. La scelta abituale per leggere.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Tre varianti che vedrai, e cosa significa ciascuna:

• for (auto x : v): x è una copia di ogni elemento. Economica per int, uno spreco per oggetti grandi.
• for (auto& x : v): x è un riferimento; puoi modificare gli elementi sul posto.
• for (const auto& x : v): x è un riferimento di sola lettura. Usalo quando devi solo leggere.

Il prossimo programma modifica il contenitore tramite auto&:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto& n : nums) {
        n *= 10;        // modifica l'elemento reale
    }

    for (const auto& n : nums) {
        cout << n << " ";   // 10 20 30
    }
    cout << "\n";
    return 0;
}

Attenzione: se in quel ciclo scrivi for (auto n : nums) (senza &), n *= 10 cambierebbe in silenzio solo la copia, lasciando nums intatto. Il compilatore non ti avvisa: il ciclo semplicemente non fa nulla di utile.

Cosa elimina auto

Un auto semplice deduce il tipo nello stesso modo di un parametro di funzione passato per valore: elimina il const di primo livello, i riferimenti e volatile. Questo significa che auto ti dà sempre una copia nuova e modificabile, a meno che tu non chieda altrimenti.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // il tipo è int, NON const int
    copy = 100;             // perfettamente legale, il const è stato eliminato

    cout << original << " " << copy << "\n";  // 42 100
    return 0;
}

Se vuoi mantenere const o evitare la copia, aggiungi tu i qualificatori. Lo schema è decorare auto come decoreresti qualsiasi altro tipo:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name = "Ada";

    const auto& ref = name;   // const std::string&: nessuna copia, sola lettura
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // errore: ref è const
    return 0;
}

Quindi auto deduce il tipo di base; &, const e * sono manopole che aggiungi sopra. auto è il tipo, const auto& è un riferimento di sola lettura a quel tipo.

Errori comuni e insidie

auto ti risparmia fatica nello scrivere, ma non ti esonera dal capire i tipi. Alcune trappole colpiscono i principianti:

Devi inizializzare. Da una dichiarazione vuota auto non ha nulla da dedurre, quindi questo è un errore di compilazione vero e proprio:

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // corretto

I letterali interi sono int, non double. auto half = 1 / 2; deduce int e memorizza 0, perché 1 / 2 è una divisione intera prima ancora che auto la veda. Il tipo segue il valore:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // divisione intera -> 0
    auto right = 1.0 / 2;    // double -> 0.5

    cout << wrong << " " << right << "\n";  // 0 0.5
    return 0;
}

auto elimina il riferimento: attenzione alle copie a sorpresa. Se una funzione restituisce un riferimento e lo prendi con un semplice auto, ottieni una copia, e in un ciclo critico a volte questo è un vero problema di prestazioni (una copia profonda di un oggetto grande a ogni iterazione). Usa const auto& quando intendi "guarda, non prendere".

Non nascondere il tipo quando conta. auto result = compute(); va bene quando il tipo restituito da compute è ovvio dal contesto, ma se chi legge deve andare a cercare cosa sia davvero result, scrivere il tipo può essere la scelta più gentile. auto serve a ridurre il rumore, non a nascondere le intenzioni.

Prossimo: Costanti e const

Hai visto che auto elimina di proposito const a meno che tu non chieda di mantenerlo, il che solleva una domanda ovvia: cosa garantisce davvero const, e quando dovresti marcare un valore come immutabile? La prossima pagina approfondisce const, le espressioni costanti e perché "rendilo const di default" è una delle abitudini più utili in C++.