mot clé automatique (type déduction)

Déduit le type d'une variable déclarée de l'expression d'initialisation.

auto declarator initializer;

Notes

Le mot clé d' auto ordonne au compilateur d'utiliser l'expression d'initialisation d'une variable déclarée pour déduire son type.

[!REMARQUE]

Avant Visual C++ 2010, le mot clé d' auto était le spécificateur de la classe de stockage automatique.Cette utilisation est maintenant une erreur.L'option du compilateur pour /Zc:auto, qui est la valeur par défaut, indique au compilateur d'utiliser la nouvelle signification du mot clé d' auto .

Nous vous recommandons d'utiliser le mot clé d' auto de la plupart situation- sauf si vous souhaitez réellement conversion- car il fournit ces avantages :

• Robustesse : si le type de l'expression modification- qui inclut lorsqu'un type de retour il modification- de fonction s'exécute immédiatement.

• Performances : vous êtes assuré qu'il n'y aura aucune conversion.

• Facilité d'utilisation : vous n'avez pas à vous préoccuper du type difficultés et typos d'orthographe du nom.

• Efficacité : votre codage peut être plus efficace.

Cas de conversion dans lesquels vous ne pouvez pas utiliser auto:

• Lorsque vous souhaitez un type spécifique et rien d'autre suffira.

• Assistance de modèle d'expression type- pour l'exemple, l' (valarray+valarray) et l'initialiseur de liste bien que rarement vous avez choisi d'écrire auto x = { 1 }; et de le comptage vraiment obtenir int.

Pour utiliser le mot clé d' auto, utilisez-le au lieu d'un type pour déclarer une variable, puis spécifiez une expression d'initialisation.En outre, vous pouvez modifier le mot clé d' auto à l'aide de les spécificateurs et des déclarateurs tels qu' const, volatile, le pointeur (*), la référence (&), et la référence (&&rvalue).Le compilateur évalue l'expression puis utilise d'initialisation ces informations pour déduire le type de la variable.

L'expression d'initialisation peut être une assignation (syntaxe de signe égal), une initialisation directe (syntaxe de style fonction), ou une expression d' opérateur new .Ou l'expression d'initialisation peut être le paramètre d' pour-intervalle-déclaration dans une instruction de Basé sur une plage, instruction (C++) .Pour plus d'informations, consultez Initialiseurs et des exemples de code plus loin dans ce document.

Le mot clé d' auto est un espace réservé pour un type, mais ce n'est pas lui-même un type.Par conséquent, le mot clé d' auto ne peut pas être utilisé dans les casts ou des opérateurs tels qu' sizeof et typeid.

Utilité

Le mot clé d' auto est un moyen simple de déclarer une variable dont le type complexe.Par exemple, vous pouvez utiliser auto pour déclarer une variable où l'expression d'initialisation implique des modèles, des pointeurs vers des fonctions, des pointeurs vers des membres.

Vous pouvez également utiliser auto pour déclarer et initialiser une variable à une expression lambda.Vous ne pouvez pas déclarer le type de la variable vous-même car le type d'une expression lambda est connu uniquement au compilateur.Pour plus d'informations, consultez Exemples d'expressions lambda.

Vous pouvez utiliser auto, avec le spécificateur de type d' decltype, pour aider à écrire des bibliothèques de modèles.Utilisez auto et decltype pour déclarer une fonction de modèle dont le type de retour dépend des types de ses arguments template.Ou, utilisez auto et decltype déclarer une fonction de modèle qui encapsule un appel à une autre fonction, et retourne ensuite celui qui est le type de retour de cette autre fonction.Pour plus d'informations, consultez spécificateur de type decltype.

Restrictions et messages d'erreur

Le tableau suivant répertorie les restrictions sur l'utilisation du mot clé d' auto, et le message d'erreur correspondant de diagnostic que les émet du compilateur.

Exemples

Ces fragments de code illustrent quelques-unes des façons dont le mot clé d' auto peut être utilisé.

Les déclarations suivantes sont équivalentes.Dans la première instruction, j variable est déclaré comme type int.Dans la deuxième instruction, k variable est déduit type int car l'expression d'initialisation (0) est un entier.

   int j = 0;  // Variable j is explicitly type int.
   auto k = 0; // Variable k is implicitly type int because 0 is an integer.

Les déclarations suivantes sont équivalentes, mais la deuxième déclaration est plus simple que la première.Une des raisons indiscutables d'utiliser le mot clé d' auto est simplicité.

   map<int,list<string>>::iterator i = m.begin(); 
   auto i = m.begin(); 

Le fragment de code suivant déclare le type de variables iter et elem lorsque les boucles d' for et d' for de plage démarrez.

// 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
    { /* ... */ }
}

Le fragment de code suivant utilise la déclaration d'opérateur et du pointeur d' new pour déclarer des pointeurs.

   double x = 12.34;
   auto *y = new auto(x), **z = new auto(&x);

Le fragment de code suivant déclare plusieurs symboles dans chaque instruction de déclaration.Notez que tous les symboles dans chaque instruction se résolvent au même type.

   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.

Ce fragment de code utilise l'opérateur conditionnel (?:) pour déclarer x variable comme un entier qui a la valeur 200 :

   int v1 = 100, v2 = 200;
   auto x = v1 > v2 ? v1 : v2;

Le fragment de code suivant initialise x variable pour taper int, y variable à une référence en type constint, et fp variable en un pointeur vers une fonction qui retourne le type 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;
    //...
}

Voir aussi

Référence

mot clé automatique

Spécificateur de classe de stockage

Mots clés C++

/Zc:auto (déduire le type de variable)

opérateur sizeof de

typeid

operator new (<new>)

Déclarations

Exemples d'expressions lambda

Initialiseurs

spécificateur de type decltype