C++
Tipo di inferenza
Ricerca…
introduzione
auto tipo che è disponibile da C ++ 11.
Osservazioni
Di solito è meglio dichiarare const e & constexpr ogni volta che si utilizza l' auto se è necessario per evitare comportamenti indesiderati come la copia o le mutazioni. Questi ulteriori suggerimenti assicurano che il compilatore non generi altre forme di inferenza. Inoltre, non è consigliabile utilizzare l' auto e deve essere utilizzato solo quando la dichiarazione effettiva è molto lunga, specialmente con i modelli STL.
Tipo di dati: automatico
Questo esempio mostra le inferenze di tipo di base che il compilatore può eseguire.
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>
Tuttavia, la parola chiave auto non esegue sempre l'inferenza di tipo prevista senza ulteriori suggerimenti per & o const o 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;
Lambda auto
Il tipo di dati parola chiave automatica è un modo conveniente per i programmatori di dichiarare funzioni lambda. Aiuta accorciando la quantità di programmatori di testo che è necessario digitare per dichiarare un puntatore a funzione.
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
Per impostazione predefinita, se il tipo restituito di funzioni lambda non è definito, verrà automaticamente dedotto dai tipi di espressione di ritorno.
Questi 3 sono fondamentalmente la stessa cosa
[](int a, int b) -> int { return a + b; };
[](int a, int b) -> auto { return a + b; };
[](int a, int b) { return a + b; };
Cicli e auto
Questo esempio mostra come auto può essere usato per abbreviare la dichiarazione del tipo per i loop
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