C++
Type Inférence
Recherche…
Introduction
auto mot-clé disponible à partir de C ++ 11.
Remarques
Il est généralement préférable de déclarer const , & et constexpr chaque fois que vous utilisez auto si cela est nécessaire pour éviter les comportements indésirables tels que la copie ou les mutations. Ces indications supplémentaires garantissent que le compilateur ne génère aucune autre forme d'inférence. Il est également déconseillé de trop utiliser auto et devrait être utilisé uniquement lorsque la déclaration réelle est très longue, en particulier avec les modèles STL.
Type de données: Auto
Cet exemple montre les inférences de type de base que le compilateur peut effectuer.
auto a = 1; // a = int
auto b = 2u; // b = unsigned int
auto c = &a; // c = int*
const auto d = c; // d = const int*
const auto& e = b; // e = const unsigned int&
auto x = a + b // x = int, #compiler warning unsigned and signed
auto v = std::vector<int>; // v = std::vector<int>
Toutefois, le mot-clé auto n'effectue pas toujours l'inférence de type attendue sans indications supplémentaires pour & ou const ou constexpr
// y = unsigned int,
// note that y does not infer as const unsigned int&
// The compiler would have generated a copy instead of a reference value to e or b
auto y = e;
Auto lambda
Le mot-clé auto type de données est un moyen pratique pour les programmeurs de déclarer les fonctions lambda. Il est utile de raccourcir la quantité de texte que les programmeurs doivent saisir pour déclarer un pointeur de fonction.
auto DoThis = [](int a, int b) { return a + b; };
// Do this is of type (int)(*DoThis)(int, int)
// else we would have to write this long
int(*pDoThis)(int, int)= [](int a, int b) { return a + b; };
auto c = Dothis(1, 2); // c = int
auto d = pDothis(1, 2); // d = int
// using 'auto' shortens the definition for lambda functions
Par défaut, si le type de retour des fonctions lambda n'est pas défini, il sera automatiquement déduit des types d'expression de retour.
Ces 3 sont fondamentalement la même chose
[](int a, int b) -> int { return a + b; };
[](int a, int b) -> auto { return a + b; };
[](int a, int b) { return a + b; };
Boucles et auto
Cet exemple montre comment auto peut être utilisé pour raccourcir la déclaration de type pour les boucles for
std::map<int, std::string> Map;
for (auto pair : Map) // pair = std::pair<int, std::string>
for (const auto pair : Map) // pair = const std::pair<int, std::string>
for (const auto& pair : Map) // pair = const std::pair<int, std::string>&
for (auto i = 0; i < 1000; ++i) // i = int
for (auto i = 0; i < Map.size(); ++i) // Note that i = int and not size_t
for (auto i = Map.size(); i > 0; --i) // i = size_t
