Auto en

À propos de Auto

Le mot-clé auto en C++

En C++, le mot-clé auto est une fonctionnalité puissante introduite en C++11, qui sert à déclarer des variables dont le type est déduit. Le compilateur déduit le type de la variable à partir de son initialiseur, ce qui peut rendre le code plus lisible et plus facile à maintenir.

Exemple d'utilisation

Prenons l'exemple suivant, où auto sert à déclarer des variables :

auto dragon_population{3};          // dragon_population is deduced as an integer
auto westeros{7.7777};              // westeros is deduced as a double
auto wedding_location{"The Twins"}; // wedding_location is deduced as a const char*, not std::string

Dans chaque cas, le type de la variable est déduit de la valeur avec laquelle elle est initialisée.

Déduction de type

Le mot-clé auto permet d'écrire du code plus concis et plus lisible en réduisant la verbosité des types explicites.

const std::vector<std::string> pigeon_pie{"flour", "butter", "pigeon", "salt"};
auto purple_wedding_pie{pigeon_pie};
purple_wedding_pie.emplace_back("the strangler");

Dans cette boucle, auto déduit le type de purple_wedding_pie comme étant std::vector<std::string>, ce qui évite de devoir spécifier à nouveau le type explicitement.

Compatibilité

Le mot-clé auto est compatible avec diverses constructions du C++, ce qui en fait un outil polyvalent dans la programmation C++ moderne.

auto& element{array[0]};           // reference to an element
const auto object{otherObject};    // const type version of otherObject's type
auto* ptr{&x};                     // pointer to x with the same type as x, but as a pointer.

Dans les concepts à venir, on verra souvent le mot-clé auto avec des expressions lambda, des boucles for basées sur un intervalle et des itérateurs.

Cas d'usage

• Programmation générique : auto est particulièrement utile dans les scénarios de programmation générique où les types peuvent être complexes ou liés à des templates.
• Types de données complexes : face à des types de données complexes ou à des noms de types longs, auto permet de réduire l'encombrement et d'améliorer la maintenabilité du code.
• Algorithmes basés sur des itérateurs : il simplifie l'utilisation des itérateurs dans les algorithmes, ce qui améliore la lisibilité du code.