spécificateur de type decltype

Article
03/04/2013

le spécificateur de type d' decltype cède le type d'une expression spécifiée.Le spécificateur de type d' decltype , avec mot clé auto, est surtout utile pour les développeurs qui écrivent des bibliothèques de modèles.Utilisez auto et decltype pour déclarer une fonction de modèle dont le type de retour dépend des types de ses arguments template.Ou, utilisez auto et decltype déclarer une fonction de modèle qui encapsule un appel à une autre fonction, et retourne le type de retour de la fonction encapsulée.

 decltype( expression )

Paramètres

Paramètre	Description
expression	Expression.Pour plus d'informations, consultez Expressions (C++).

Valeur de retour

Type du paramètre expression.

Notes

Le spécificateur de type d' decltype est pris en charge dans Visual C++ 2010 ou versions ultérieures, et peut être utilisé avec le code natif ou le code managé.

Le compilateur utilise les règles suivantes pour déterminer le type du paramètre d' expression .

si le paramètre d' expression est un identificateur ou un accès aux membres de classe, decltype(expression) est le type de l'entité nommée par expression.S'il n'y a aucune entité ou les noms de paramètres d' expression un ensemble de fonctions surchargées, le compilateur génère un message d'erreur.
Si le paramètre d' expression est un appel à une fonction ou une fonction surchargée d'opérateur, decltype(expression) est le type de retour de la fonction.Des parenthèses autour d'un opérateur surchargé sont ignorées.
si le paramètre d' expression est rvalue, decltype(expression) est le type d' expression.si le paramètre d' expression est l-value, decltype(expression) est référence lvalue au type d' expression.

l'exemple de code suivant montre quelques utilisations du spécificateur de type d' decltype .d'abord, supposez que vous avez codé les instructions suivantes.

int var;
const int&& fx(); 
struct A { double x; }
const A* a = new A();

Ensuite, examinez les types retournés par les quatre instructions d' decltype dans le tableau suivant.

Instruction	Type	Remarques
decltype(fx());	const int&&	référence rvalue à const int.
decltype(var);	int	le type de variable var.
decltype(a->x);	double	Le type de l'accès au membre.
decltype((a->x));	const double&	Les parenthèses internes provoquent l'instruction à évaluer comme expression au lieu d'un accès au membre.Étant donné qu' a est déclaré comme pointeur d' const , le type est une référence à const double.

Decltype et auto

Utilisez le spécificateur de type d' decltype , avec le mot clé d' auto , pour déclarer une fonction de modèle dont le type de retour dépend des types de ses arguments template.par exemple, considérez l'exemple de code suivant dans lequel le type de retour de la fonction de modèle dépend des types des arguments template.Dans l'exemple de code, l'espace réservé d' INCONNU indique le type de retour ne peut pas être spécifié.

template<typename T, typename U>
UNKNOWNfunc(T&& t, U&& u){ return t + u; };

L'introduction du spécificateur de type d' decltype permet à un développeur pour obtenir le type de l'expression que la fonction de modèle retourne.Utilisez une autre syntaxe de déclaration de fonction qui est illustrée plus loin, le mot clé d' auto , et le spécificateur de type d' decltype pour déclarer un type de retour tard-spécifié .Le type de retour tard-spécifié est déterminé lorsque la déclaration est compilée, au lieu de lorsqu'il est codé.

le prototype suivant illustre la syntaxe d'une autre déclaration de fonction.notez que les qualificateurs d' const et d' volatile , et throwspécification d'exception sont facultatifs.L'espace réservé de function_body représente une instruction composée qui indique la fonction accomplit.Comme meilleure pratique de codage, l'espace réservé d' expression dans l'instruction d' decltype doit correspondre à l'expression spécifiée par l'instruction d' return , le cas échéant, dans function_body.

autonom_fonction(paramètresopt)constoptvolatileopt−>decltype(expression)throwopt{function_body};

dans l'exemple de code suivant, le type de retour tard-spécifié de la fonction de modèle d' myFunc est déterminé par les types des arguments template d' t et d' u .Comme meilleure pratique de codage, l'exemple de code utilise également les références rvalue et le modèle de fonction d' forward , qui prennent en charge le transfert parfait.Pour plus d'informations, consultez Déclarateur de référence Rvalue : &&.

template<typename T, typename U>
auto myFunc(T&& t, U&& u) -> decltype (forward<T>(t) + forward<U>(u)) 
        { return forward<T>(t) + forward<U>(u); };

Decltype et fonctions de migration

transférer des appels d'enveloppe de fonctions à d'autres fonctions.Utilisez un modèle de fonction qui transfère ses arguments, ou les résultats d'une expression qui implique ces arguments, à une autre fonction.De plus, la fonctionnalité de migration retourne le résultat d'appeler un autre fonction.Dans ce scénario, le type de retour de la fonction de migration doit être le même que le type de retour de la fonction encapsulée.

Dans ce scénario, vous ne pouvez pas entrer une expression de type correcte sans spécificateur de type d' decltype .Le spécificateur de type d' decltype active des fonctionnalités génériques de migration car il ne perd pas les informations requises pour indiquer si une fonction retourne un type référence.Pour obtenir un exemple de code d'une fonction de migration, consultez l'exemple précédent de fonction de modèle d' myFunc .

Exemple

l'exemple de code suivant déclare le type de retour tard-spécifié de fonction **Plus()**de modèle.la fonction d' Plus traite ses deux opérandes avec la surcharge d' operator+ .Par conséquent, la traduction de l'opérateur plus (+) et le type de retour de la fonction d' Plus dépend des types d'arguments de fonction.

// decltype_1.cpp
// compile with: /EHsc
//
#include "stdafx.h"
#include <iostream>
#include <string>
#include <utility>
#include <iomanip>

using namespace std;

template<typename T1, typename T2>
auto Plus(T1&& t1, T2&& t2) -> 
   decltype(forward<T1>(t1) + forward<T2>(t2))
{
   return forward<T1>(t1) + forward<T2>(t2);
}

class X
{
   friend X operator+(const X& x1, const X& x2)
   {
      return X(x1.m_data + x2.m_data);
   }

public:
   X(int data) : m_data(data) {}
   int Dump() const { return m_data;}
private:
   int m_data;
};

int main()
{
   // Integer 
   int i = 4;
   cout << 
      "Plus(i, 9) = " << 
      Plus(i, 9) << endl;

   // Floating point
   float dx = 4.0;
   float dy = 9.5;
   cout <<   
      setprecision(3) << 
      "Plus(dx, dy) = " <<
      Plus(dx, dy) << endl;

   // String      
   string hello = "Hello, ";
   string world = "world!";
   cout << Plus(hello, world) << endl;

   // Custom type
   X x1(20);
   X x2(22);
   X x3 = Plus(x1, x2);
   cout << 
      "x3.Dump() = " << 
      x3.Dump() << endl;
}

Sortie

Cet exemple de code montre les résultats suivants.

13.5

Hello, world !

Configuration requise

Visual C++ 2010 ou versions ultérieures.

Voir aussi

Référence

Type simple noms

Partager via