Parola chiave auto (deduzione del tipo)
Deduce il tipo di una variabile dichiarata dall'espressione di inizializzazione.
auto declarator initializer;
Note
La parola chiave auto indica al compilatore di utilizzare l'espressione di inizializzazione di una variabile dichiarata per dedurre il tipo.
Si consiglia di utilizzare la parola chiave auto per la maggior parte delle situazioni, a meno che non si desideri effettivamente una conversione, perché offre i vantaggi seguenti:
Affidabilità: Se il tipo dell'espressione viene cambiato, questo include quando il tipo restituito dalla funzione cambia, esso continua a funzionare.
Prestazioni: Si garantisce che non vi sarà conversione.
Usabilità: Non è necessario preoccuparsi delle difficoltà e degli errori di digitazione del nome del tipo.
Efficienza: La codifica può essere più efficiente.
Casi di conversione in cui non è consigliabile utilizzare auto:
Quando si desidera un tipo specifico e nient'altro.
Tipi di supporto del modello di espressione, ad esempio (valarray+valarray) e liste di inizializzazione, benché raramente si scrive auto x = { 1 }; e effettivamente si vuole ottenere un int.
Per utilizzare la parola chiave auto, utilizzata al posto di un tipo per dichiarare una variabile e specificare un'espressione di inizializzazione. Inoltre, è possibile modificare la parola chiave auto utilizzando identificatori e dichiaratori come const, volatile, pointer (*), reference (&) e rvalue reference (&&). Il compilatore valuta l'espressione di inizializzazione quindi utilizza tali informazioni per dedurre il tipo della variabile.
L'espressione di inizializzazione può essere un'assegnazione (sintassi del segno di uguale), un'inizializzazione diretta (sintassi di tipo funzione), un espressione operator new, o l'espressione di inizializzazione può essere il parametro for-range-declaration in un'istruzione Istruzione for basata su intervallo (C++). Per ulteriori informazioni, vedere Inizializzatori e gli esempi di codice più avanti in questo argomento.
La parola chiave auto è un segnaposto per un tipo, ma essa non è un tipo. Di conseguenza, la parola chiave auto non può essere utilizzata in un cast o al posto di un operatore come sizeof e typeid (Estensioni del componente C++).
Utilizzabilità
La parola chiave auto è un modo semplice per dichiarare una variabile che ha un tipo complesso. Ad esempio, è possibile utilizzare auto per dichiarare una variabile in cui l'espressione di inizializzazione include modelli, puntatori a funzione o puntatori a membro.
È inoltre possibile utilizzare auto per dichiarare e inizializzare una variabile in un'espressione lambda. Non è possibile dichiarare il tipo della variabile manualmente poiché il tipo di un'espressione lambda è noto solo al compilatore. Per ulteriori informazioni, vedere Esempi di espressioni lambda.
Tipi restituiti finali
È possibile utilizzare auto, insieme all'identificatore di tipo decltype, per aiutare a scrivere le librerie del modello. Utilizzare auto e decltype per dichiarare una funzione di modello il cui tipo restituito dipende dai tipi degli argomenti di modello corrispondenti. In alternativa, utilizzare auto e decltype per dichiarare una funzione di modello che esegue il wrapping di una chiamata ad un'altra funzione e quindi restituisce il tipo restituito dell'altra funzione. Per ulteriori informazioni, vedere Identificatore di tipo decltype.
Riferimenti e qualificatori cv
Si noti che tramite i riferimenti di destinazione auto, i qualificatori const e i qualificatori volatili. Si consideri l'esempio seguente:
// cl.exe /analyze /EHsc /W4
#include <iostream>
using namespace std;
int main( )
{
int count = 10;
int& countRef = count;
auto myAuto = countRef;
countRef = 11;
cout << count << " ";
myAuto = 12;
cout << count << endl;
}
È possibile credere che il myAuto sia un riferimento di int, ma non lo è. È semplicemente un int, pertanto l'output è 11 11, non 11 12 come sarebbe il caso se il riferimento non è stato rilasciato da auto.
Restrizioni e messaggi di errore
Nella tabella seguente sono elencate le restrizioni sull'utilizzo della parola chiave auto e il messaggio di errore diagnostico corrispondente che il compilatore genera.
Errore numero |
Descrizione |
|---|---|
La parola chiave auto non può essere combinata con nessun altro specificatore di tipo. |
|
Un simbolo dichiarato con la parola chiave auto deve disporre di un inizializzatore. |
|
È stato utilizzato in modo errato la parola chiave auto per dichiarare un tipo. Ad esempio, è stato dichiarato un tipo restituito di un metodo o un array. |
|
Un parametro o un argomento di modello non può essere dichiarato con la parola chiave auto. |
|
Un simbolo dichiarato con la parola chiave auto in un'espressione new deve disporre di un inizializzatore. Per ulteriori informazioni, vedere operator new (<new>). |
|
Un parametro di argomento o di modello non può essere dichiarato con la parola chiave auto. |
|
Un simbolo non può essere utilizzato prima che venga inizializzato In pratica, questo significa che una variabile non può essere utilizzata per inizializzare se stessa. |
|
Non è possibile eseguire il cast a un tipo dichiarato con la parola chiave auto. |
|
Tutti i simboli in una lista dichiaratrice che è dichiarata con la parola chiave auto devono risolvere lo stesso tipo. Per ulteriori informazioni, vedere Dichiarazioni. |
|
Gli operatori typeid (Estensioni del componente C++) e sizeof non possono essere applicati a un simbolo dichiarato con la parola chiave auto. |
Esempi
Questi frammenti di codice illustrano alcune modalità in cui la parola chiave auto può essere utilizzata.
Le dichiarazioni seguenti sono equivalenti. Nella prima istruzione, la variabile j è dichiarata come tipo int. Nella seconda istruzione, la variabile k viene dedotta essere di tipo int perché l'espressione di inizializzazione (0) è un integer.
int j = 0; // Variable j is explicitly type int.
auto k = 0; // Variable k is implicitly type int because 0 is an integer.
Le dichiarazioni seguenti sono equivalenti ma la seconda dichiarazione è più semplice della prima. Una delle ragioni più valide per l'utilizzo della parola chiave auto è la semplicità.
map<int,list<string>>::iterator i = m.begin();
auto i = m.begin();
Il frammento di codice seguente dichiara il tipo delle variabili iter e elem quando i cicli for e range for iniziano.
// cl /EHsc /nologo /W4
#include <deque>
using namespace std;
int main()
{
deque<double> dqDoubleData(10, 0.1);
for (auto iter = dqDoubleData.begin(); iter != dqDoubleData.end(); ++iter)
{ /* ... */ }
// prefer range-for loops with the following information in mind
// (this applies to any range-for with auto, not just deque)
for (auto elem : dqDoubleData) // COPIES elements, not much better than the previous examples
{ /* ... */ }
for (auto& elem : dqDoubleData) // observes and/or modifies elements IN-PLACE
{ /* ... */ }
for (const auto& elem : dqDoubleData) // observes elements IN-PLACE
{ /* ... */ }
}
Il frammento di codice seguente usa l'operatore new e la dichiarazione pointer per dichiarare i puntatori.
double x = 12.34;
auto *y = new auto(x), **z = new auto(&x);
Il frammento di codice seguente dichiara più simboli in ogni istruzione di dichiarazione. Si noti che tutti i simboli in ogni istruzione risolvono lo stesso tipo.
auto x = 1, *y = &x, **z = &y; // Resolves to int.
auto a(2.01), *b (&a); // Resolves to double.
auto c = 'a', *d(&c); // Resolves to char.
auto m = 1, &n = m; // Resolves to int.
Questo frammento di codice utilizza l'operatore condizionale (?:) per dichiarare la variabile x come integer con un valore di 200:
int v1 = 100, v2 = 200;
auto x = v1 > v2 ? v1 : v2;
Il frammento di codice successivo inizializza la variabile x come int, la variabile y come riferimento sul tipo const int e la variabile fp come puntatore a una funzione che restituisce il tipo int.
int f(int x) { return x; }
int main()
{
auto x = f(0);
const auto & y = f(1);
int (*p)(int x);
p = f;
auto fp = p;
//...
}
Vedere anche
Riferimenti
Identificatori di classi di archiviazione
/Zc:auto (deduzione del tipo di variabile)