decltype vs auto

Según tengo entendido, tanto decltype como auto intentarán averiguar qué tipo de objeto es.decltype vs auto

Si definimos:

int foo() { 
    return 34; 
}

A continuación, ambas declaraciones son legales:

auto x = foo(); 
cout << x << endl; 

decltype(foo()) y = 13; 
cout << y << endl;

Podría por favor, dígame cuál es la principal diferencia entre decltype y auto es?

Fuente

2012-08-23 James Leonard

@JesseGood Antes de hacer la pregunta, leí ese hilo y estoy buscando una explicación más clara –

Preguntas similares: [1]: http://stackoverflow.com/questions/11459928/equivalence-between-decltype-and- auto [2]: http://stackoverflow.com/questions/6869888/the-relationship-between-auto-and-decltype – crnlx

@JamesLeonard: Bueno, bueno, no sé una mejor explicación [que la de Scott Meyers] (http: // cpp-next.com/archive/2011/04/appearing-and-disappearing-consts-in-c /). –

decltype da declarado tipo de la expresión que se le pasa. auto hace lo mismo que la deducción del tipo de plantilla. Entonces, por ejemplo, si tiene una función que devuelve una referencia, auto seguirá siendo un valor (necesita auto& para obtener una referencia), pero decltype será exactamente el tipo del valor de retorno.

#include <iostream> 
int global{}; 
int& foo() 
{ 
    return global; 
} 

int main() 
{ 
    decltype(foo()) a = foo(); //a is an `int&` 
    auto b = foo(); //b is an `int` 
    b = 2; 

    std::cout << "a: " << a << '\n'; //prints "a: 0" 
    std::cout << "b: " << b << '\n'; //prints "b: 2" 

    std::cout << "---\n"; 
    decltype(foo()) c = foo(); //c is an `int&` 
    c = 10; 

    std::cout << "a: " << a << '\n'; //prints "a: 10" 
    std::cout << "b: " << b << '\n'; //prints "b: 2" 
    std::cout << "c: " << c << '\n'; //prints "c: 10" 
}

Véase también la respuesta de David Rodríguez acerca de los lugares en los que sólo son posibles o uno de autodecltype.

Fuente

2012-08-23 02:53:25 Mankarse

auto (en el contexto donde se deduce un tipo) se limita a definir el tipo de una variable para la que hay un inicializador. decltype es una construcción más amplia que, a costa de información adicional, deducirá el tipo de una expresión.

En los casos en que se puede usar auto, es más conciso que decltype, ya que no es necesario proporcionar la expresión de la que se deducirá el tipo.

auto x = foo();       // more concise than `decltype(foo()) x` 
std::vector<decltype(foo())> v{ foo() }; // cannot use `auto`

La palabra clave auto también se utiliza en un contexto completamente ajenos, al utilizar trailing tipos de retorno para las funciones:

auto foo() -> int;

Hay auto es sólo un líder para que el compilador sabe que esto es una declaración con un tipo de retorno final. Aunque el ejemplo anterior puede ser trivial se convirtió al estilo antiguo, en la programación genérica es útil:

template <typename T, typename U> 
auto sum(T t, U u) -> decltype(t+u)

Tenga en cuenta que en este caso, auto no se puede utilizar para definir el tipo de retorno.

Fuente

2012-08-23 02:55:18

Generalmente, si usted necesita un tipo para una variable que se va a inicializar, utilice automático. decltype se usa mejor cuando necesita el tipo de algo que no es una variable, como un tipo de devolución.

Fuente

2016-07-07 12:13:42 Ankur

Respuesta

Cuestiones relacionadas