Sök…


Introduktion

Det här ämnet diskuterar typinferenser som involverar nyckelordet auto typ som är tillgängligt från C ++ 11.

Anmärkningar

Det är vanligtvis bättre att deklarera const & constexpr när du använder auto om det någonsin krävs för att förhindra oönskat beteende som kopiering eller mutationer. Dessa extra tips säkerställer att kompilatorn inte genererar några andra former av inferens. Det är inte heller tillrådligt att använda över auto och bör bara användas när den faktiska deklarationen är mycket lång, särskilt med STL-mallar.

Datatyp: Auto

Detta exempel visar de grundläggande slutsatserna som kompilatorn kan utföra.

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>

Auto-nyckelordet utför emellertid inte alltid den förväntade slutsatsen utan ytterligare tips för & eller const eller 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

Datatypens auto-nyckelord är ett bekvämt sätt för programmerare att deklara lambda-funktioner. Det hjälper genom att förkorta mängden textprogrammerare behöver skriva för att förklara en funktionspekare.

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

Om returntypen för lambdafunktioner inte är definierad, kommer den automatiskt att härledas från returuttryckstyperna.

Dessa 3 är i princip samma sak

[](int a, int b) -> int  { return a + b; };
[](int a, int b) -> auto { return a + b; };
[](int a, int b) { return a + b; };

Loops och auto

Detta exempel visar hur auto kan användas för att förkorta typdeklarationen för slingor

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
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow