Zoeken…


Invoering

In dit onderwerp wordt ingegaan op type-inferencing met het trefwoord 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


Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow