Recherche…


Introduction

Cette rubrique traite de l'inférence de type impliquant le type 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


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow