C++
Type Inferentie
Zoeken…
Invoering
auto type dat beschikbaar is bij C ++ 11.
Opmerkingen
Het is meestal beter om const , & en constexpr wanneer u auto als dit ooit nodig is om ongewenst gedrag zoals kopiëren of mutaties te voorkomen. Die extra tips zorgen ervoor dat de compiler geen andere vormen van inferentie genereert. Het is ook niet aan te raden om auto te veel te gebruiken en mag alleen worden gebruikt wanneer de daadwerkelijke aangifte erg lang is, vooral met STL-sjablonen.
Gegevenstype: Auto
Dit voorbeeld toont de basistype gevolgtrekkingen die de compiler kan uitvoeren.
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>
Het automatische sleutelwoord voert echter niet altijd de verwachte type-inferentie uit zonder aanvullende aanwijzingen voor & of const of 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
Het gegevenstype automatisch sleutelwoord is een handige manier voor programmeurs om lambdafuncties aan te geven. Het helpt door de hoeveelheid tekstprogrammeurs te typen die nodig is om een functie-aanwijzer te declareren.
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
Als het retourtype van lambdafuncties niet is gedefinieerd, wordt het automatisch afgeleid uit de retouruitdrukkingstypen.
Deze 3 is eigenlijk hetzelfde
[](int a, int b) -> int { return a + b; };
[](int a, int b) -> auto { return a + b; };
[](int a, int b) { return a + b; };
Lussen en automatisch
Dit voorbeeld laat zien hoe auto kan worden gebruikt om de typeaangifte in te korten voor lussen
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