parola chiave auto (deduzione del tipo)
Deduce il tipo di variabile dichiarata dall'espressione di inizializzazione.
auto declarator initializer;
Note
La parola chiave di auto indica al compilatore di utilizzare l'espressione di inizializzazione di una variabile dichiarata per dedurre il tipo.
[!NOTA]
Prima di Visual C++ 2010, la parola chiave di auto è l'identificatore della classe di archiviazione automatica.Tale utilizzo è ora un errore.L'opzione del compilatore di /Zc:auto, ovvero l'impostazione predefinita, indica al compilatore di utilizzare il nuovo significato della parola chiave di auto.
Si consiglia di utilizzare la parola chiave di auto per la maggior parte situazione- a meno che in pensione conversione perché offre i vantaggi seguenti:
Affidabilità: se il tipo dell'espressione stessi questo include quando un tipo restituito dalla funzione semplicemente funzionamento.
Prestazioni: si garantisce che non sarà conversione.
Usabilità: non è necessario preoccuparsi delle difficoltà e gli 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 l'ancoraggio sufficiente.
Supporto del modello di espressione tipo, ad esempio (valarray+valarray) e l'inizializzatore elenco- anche se si sceglie raramente per scrivere auto x = { 1 }; };e effettivamente per considerare per ottenere int.
Per utilizzare la parola chiave di auto, utilizzarlo anziché un tipo per dichiarare una variabile e specificare un'espressione di inizializzazione.Inoltre, è possibile modificare la parola chiave di auto utilizzando identificatori e i dichiaratori come const, volatile, il puntatore*(), il riferimento (&) e rvalue (&&di riferimento).Il compilatore valuta l'espressione di inizializzazione e di utilizzare tali informazioni 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, oppure un'espressione di operatore new.O l'espressione di inizializzazione può essere il parametro di per-intervallo-dichiarazione in un'istruzione di Istruzione for basata su intervallo (C++).Per ulteriori informazioni, vedere più avanti Inizializzatori ed esempi di codice in questo documento.
La parola chiave di auto è un segnaposto per un tipo, ma non è un tipo.Pertanto, la parola chiave di auto non può essere utilizzata in un cast o in operatori come sizeof e typeid.
L'utilità
La parola chiave di auto è un modo semplice per dichiarare una variabile con un tipo complesso.Ad esempio, è possibile utilizzare auto per dichiarare una variabile in cui l'espressione di inizializzazione include modelli, puntatori a funzioni, 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.
È possibile utilizzare auto, insieme all'identificatore del tipo di decltype, per consentire di scrivere le librerie del modello.Utilizzare auto e decltype per dichiarare una funzione di modello con tipo restituito dipende dai tipi degli argomenti.In alternativa, utilizzare auto e decltype dichiarare una funzione di modello che esegue il wrapping di una chiamata a un'altra funzione e quindi restituisce uno è il tipo restituito di a un'altra funzione.Per ulteriori informazioni, vedere identificatore di tipo decltype.
Restrizioni e messaggi di errore
Nella tabella seguente sono elencate le restrizioni sull'utilizzo della parola chiave di auto e il messaggio di errore diagnostico corrispondente che il compilatore genera.
Numero di errore |
Descrizione |
|---|---|
La parola chiave di auto non può essere combinato con qualsiasi altro identificatore. |
|
Un simbolo dichiarato con la parola chiave di auto deve disporre di un inizializzatore. |
|
È stato utilizzato in modo errato la parola chiave di auto per dichiarare un tipo.Ad esempio, è stato dichiarato un tipo restituito di un metodo o una matrice. |
|
Un parametro o un argomento di modello non può essere dichiarato con la parola chiave di auto. |
|
Un simbolo dichiarato con la parola chiave di auto in un'espressione di new deve disporre di un inizializzatore.Per ulteriori informazioni, vedere operator new (<new>). |
|
Un metodo o un parametro di modello non può essere dichiarato con la parola chiave di 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 di auto. |
|
Tutti i simboli in un dichiaratore elenco dichiarato con la parola chiave di auto deve risolvere lo stesso tipo.Per ulteriori informazioni, vedere Dichiarazioni. |
|
Gli operatori di typeid e di sizeof non possono essere applicate a un simbolo dichiarato con la parola chiave di auto. |
Esempi
Questi frammenti di codice vengono illustrate alcune modalità in cui la parola chiave di auto può essere utilizzata.
Le dichiarazioni seguenti sono equivalenti.Nella prima istruzione, j variabile è dichiarato come tipo int.Nella seconda istruzione, k variabile viene dedotto per essere 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, mentre la seconda dichiarazione è più semplice del primo.Una delle ragioni valide per l'utilizzo della parola chiave di auto è semplicità.
map<int,list<string>>::iterator i = m.begin();
auto i = m.begin();
Nel frammento di codice dichiara il tipo di variabili iter e elem quando i cicli di for l'intervallo e di for l'avvio.
// 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
{ /* ... */ }
}
Nel frammento di codice utilizza la dichiarazione dell'operatore e del puntatore di new per dichiarare i puntatori.
double x = 12.34;
auto *y = new auto(x), **z = new auto(&x);
Il frammento di codice seguente dichiara i simboli in ogni istruzione di dichiarazione.Si noti che tutti i simboli in ogni risoluzione dell'istruzione allo 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.
Nel frammento di codice utilizza l'operatore condizionale (?:) per dichiarare x variabile come Integer che ha un valore 200:
int v1 = 100, v2 = 200;
auto x = v1 > v2 ? v1 : v2;
Nel frammento di codice che inizializza x variabile per immettere int, y variabile a un riferimento a constinte fp variabile in un puntatore a una funzione che restituisce digitare 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 classe di archiviazione