C++
Inferencia de tipos
Buscar..
Introducción
auto palabra clave que está disponible en C ++ 11.
Observaciones
Por lo general, es mejor declarar const , & y constexpr siempre que use auto si alguna vez se requiere para prevenir comportamientos no deseados como copiar o mutaciones. Esos consejos adicionales aseguran que el compilador no genere ninguna otra forma de inferencia. Tampoco es aconsejable el uso excesivo auto y debe utilizarse solo cuando la declaración real es muy larga, especialmente con las plantillas STL.
Tipo de datos: Auto
Este ejemplo muestra las inferencias de tipo básico que puede realizar el compilador.
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>
Sin embargo, la palabra clave auto no siempre realiza la inferencia de tipo esperada sin sugerencias adicionales para & 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
La palabra clave auto del tipo de datos es una forma conveniente para que los programadores declaren funciones lambda. Ayuda al acortar la cantidad de texto que los programadores necesitan escribir para declarar un puntero a función.
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
De forma predeterminada, si el tipo de retorno de las funciones lambda no está definido, se deducirá automáticamente de los tipos de expresión de retorno.
Estos 3 es básicamente lo mismo.
[](int a, int b) -> int { return a + b; };
[](int a, int b) -> auto { return a + b; };
[](int a, int b) { return a + b; };
Bucles y auto
Este ejemplo muestra cómo se puede usar auto para acortar la declaración de tipos para los bucles
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
