web-dev-qa-db-fra.com

decltype vs auto

Si je comprends bien, decltype et auto tenteront de déterminer le type de quelque chose.

Si on définit:

int foo () {
    return 34;
}

Alors les deux déclarations sont légales:

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

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

Pourriez-vous me dire quelle est la principale différence entre decltype et auto?

c++type-inference
36
James Leonard

decltype donne le type déclaré de l'expression qui lui est transmise. auto fait la même chose que la déduction de type de modèle. Ainsi, par exemple, si vous avez une fonction qui renvoie une référence, auto sera toujours une valeur (vous aurez besoin de auto& pour obtenir une référence), mais decltype sera exactement le type de la valeur de retour.

#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"
 }

Voir également la réponse de David Rodríguez sur les endroits où un seul parmi auto ou decltype est possible.

34
Mankarse

auto (dans le contexte où il en déduit un type) est limité à la définition du type d'une variable pour laquelle il existe un initialiseur. decltype est une construction plus large qui, au prix d'informations supplémentaires, induira le type d'une expression.

Dans les cas où auto peut être utilisé, il est plus concis que decltype, car vous n'avez pas besoin de fournir l'expression à partir de laquelle le type sera déduit.

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

Le mot clé auto est également utilisé dans un contexte totalement indépendant lorsque des types de retour de fin sont utilisés pour les fonctions:

auto foo() -> int;

auto n’est qu’un leader pour que le compilateur sache qu’il s’agit d’une déclaration avec un type de retour final. Bien que l’exemple ci-dessus puisse être converti trivialement en style ancien, il est utile, en programmation générique:

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

Notez que dans ce cas, auto ne peut pas être utilisé pour définir le type de retour.

33
David Rodríguez - dribeas

Généralement, si vous avez besoin d’un type pour une variable à initialiser, utilisez auto . decltype est mieux utilisé lorsque vous avez besoin du type pour quelque chose qui n'est pas une variable, comme un type de retour.

0
Ankur