Quand dois-je utiliser decltype(x) au lieu de auto pour déclarer le type d'une variable ?

Question

Je vois. decltype(x) utilisé à l'intérieur de macros où x est un nom de variable car le type de l'objet n'est pas connu dans les macros.

Par exemple :

decltype(x) y = expr;

J'aurais pu facilement utiliser auto au lieu de decltype . Alors quelles sont ces situations où decltype est nécessaire pour une déclaration de type de variable au lieu de auto ?

Answer 1

Vous devez l'utiliser lorsque le type de y est :

• différent (ou potentiellement différent) du type de expr . Si c'était la même chose, alors auto serait plus concis.
• de même pour auto & ou d'autres modifications du type de expr que auto peut exprimer.

et l'un des éléments suivants :

• dépendent de quelque chose dans le code environnant (c'est-à-dire qu'ils ne sont pas toujours du même type) et sont difficiles à écrire en utilisant des traits de type ou similaires. Cela aura tendance à se produire dans le code de template. Il peut y avoir un trait de type que vous pouvez utiliser pour obtenir le type requis à partir des paramètres du modèle, mais il se peut aussi qu'il n'y ait pas d'utilisation de l'option decltype vous éviterait d'en définir un.
• toujours du même type (ou dépendant des paramètres du modèle d'une manière qui est facile à exprimer en utilisant les traits de type existants ou similaires) mais le type est très long à écrire et il existe une expression beaucoup plus courte et claire que vous pouvez utiliser à la place.

Ainsi, par exemple, en remplaçant std::iterator_traits<RandomAccessIterator>::value_type avec decltype(*it) pourrait bien être une victoire, bien que auto s'occupe souvent de ces cas.

Les jugements subjectifs interviennent au niveau de "ce qui est difficile", "ce qui est long" et "ce qui est clair", mais les règles de procédure peuvent être les mêmes, quelle que soit la façon dont vous faites ces jugements dans des cas spécifiques.

Answer 2

Quand vous voulez y pour avoir toujours ce que le type déclaré de x est.

Answer 3

decltype devient pratique lorsque vous devez retourner un type inconnu, qui est évalué lors de la compilation :

template<class A, class B>
void MultiplyAB(A a, B b, decltype(a*b)& output)
{
    output = a * b;
}

De plus, si vous n'aimez pas la façon dont la sortie est gérée par une référence, vous pouvez également utiliser le type de retour spécifié tardivement (et utiliser également la méthode de retour de la référence). decltype ) :

template<class A, class B>
auto MultiplyAB(A a, B b) -> decltype(a*b)
{
    return a * b;
}

Tout cela, et bien plus encore, est décrit par B. Stroustrup dans l'ouvrage intitulé FAQ C++ .

Answer 4

Lorsque le type de votre variable n'est pas lié à l'expression évaluée.

Par exemple

struct Bar
{
    Bar(int) {} // implicitly constructable
}

struct Bar2
{
    Bar2(int) {} // implicitly constructable
}

struct Foo
{
    static Bar var;
}

struct Foo2
{
    static Bar2 var;
}

template <typename T>
void dummy()
{
    decltype(T::var) myVar = 42;
}

dummy<Foo>(); // myVar is of type Bar1
dummy<Foo2>(); // myVar is of type Bar2
auto myAutoVar = 42; // type is int

Bien sûr, ce n'est qu'un cas d'utilisation, il y en a beaucoup d'autres.

Answer 5

decltype est nettement plus polyvalent que auto et peut toujours être utilisé à sa place. Par conséquent, je pense qu'il est assez sûr de dire que decltype ne doit être utilisé que dans les cas où il est complètement nécessaire, donc si auto produit un résultat erroné, vous devez utiliser decltype. De plus, vous ne pouvez pas encore utiliser auto dans les types de retour et les paramètres, de sorte que vous pouvez utiliser decltype là aussi. C++14 augmentera de manière significative les utilisations potentielles de auto et je suppose que c++17 ira plus loin. Ainsi, les situations à utiliser decltype ne sera que lorsque vous aurez besoin de changer le type de résultats de expr

Un autre élément à prendre en compte est que decltype n'est pas vraiment nécessaire à moins que vous n'écriviez du code de bibliothèque, auto est agréable pour la programmation de tous les jours si vous voulez rendre votre code plus concis, c'est un débat pour savoir si utiliser autant de auto C'est une bonne chose, mais c'est pratiquement nécessaire lorsque l'on travaille avec des types indéfinissables comme les lambdas.