Inférence de type avec le mot-clé auto en C++

L'inférence de type fait référence à la déduction automatique du type de données d'une expression dans un langage de programmation. Avant C++ 11, chaque type de données devait être explicitement déclaré au moment de la compilation, limitant les valeurs d'une expression à l'exécution, mais après la nouvelle version de C++, de nombreux mots-clés sont inclus, ce qui permet à un programmeur de laisser la déduction de type au compilateur lui-même .

Avec les capacités d'inférence de type, nous pouvons passer moins de temps à écrire des choses que le compilateur connaît déjà. Comme tous les types sont déduits uniquement dans la phase de compilation, le temps de compilation augmente légèrement mais cela n'affecte pas le temps d'exécution du programme.

Vous utilisez le mot clé auto pour indiquer que le compilateur doit déduire le type d'une variable.

Exemple 1

auto m {10};  // m est de type int
auto n {200UL};  // n est de type long non signé
auto p {std::numbers::pi};  // p est de type double
        

Le compilateur déduira les types de m, n et p à partir des valeurs initiales que vous fournissez. Vous pouvez également utiliser la notation fonctionnelle ou d'affectation avec auto pour la valeur initiale :

Exemple 2

auto m = 10;  // m est de type int
auto n = 200UL;  // n est de type long non signé
auto p {std::numbers::pi};  // p est de type double
        

Cela dit, ce n'est pas vraiment ainsi que le mot-clé auto est censé être utilisé. Lorsque vous définissez des variables de types fondamentaux, vous pourriez souvent aussi bien spécifier le type explicitement. Nous reviendrons sur le mot-clé auto plus tard dans ce tutoriel, où il est appliqué de manière plus appropriée et beaucoup plus utile.

Vous devez être prudent lorsque vous utilisez des initialisateurs entre accolades avec le mot-clé auto. Par exemple, supposons que vous écriviez ceci (remarquez le signe égal !):

auto m = {10};

Alors le type déduit pour m ne sera pas int, mais plutôt std::initializer_list<int>. Pour vous donner un contexte, c'est le même type que vous obtiendriez si vous utilisiez une liste d'éléments entre les accolades :

auto liste = {1, 2, 3};

Exemple 3

/* C++11 et C++14 */
auto i {10};   // i est de type std::initializer_list<int> !!!
auto pi = {3.14159};  // pi est de type std::initializer_list<double>
auto liste1{1, 2, 3};  // liste1 est de type std::initializer_list<int>
auto liste2 = {4, 5, 6};  // liste2 est de type std::initializer_list<int>


/* C++17 et versions ultérieures */
auto i {10};  // i est de type int
auto pi = {3.14159};  // pi est de type std::initializer_list<double>
auto liste1{1, 2, 3};  // erreur : ne compile pas!
auto liste2 = {4, 5, 6};  // liste2 est de type std::initializer_list<int>
        

Pour résumer, si votre compilateur prend correctement en charge C++17, vous pouvez utiliser l'initialisation entre accolades pour initialiser n'importe quelle variable avec une valeur unique, à condition de ne pas la combiner avec une affectation. Si votre compilateur n'est pas encore complètement à jour, vous ne devriez jamais utiliser d'initialiseurs entre accolades avec auto. Au lieu de cela, indiquez explicitement le type ou utilisez l'affectation ou la notation fonctionnelle.