identificatore di tipo decltype

Articolo
03/05/2013

decltype l'identificatore del tipo base al tipo di espressione specificata.decltype identificatore del tipo, insieme a parola chiave auto, è utile principalmente agli sviluppatori che scrivono librerie del modello.utilizzo auto e decltype per dichiarare una funzione di modello che il tipo restituito dipende dai tipi degli argomenti di modello.In alternativa, utilizzare auto e decltype per dichiarare un template funzionare che esegue il wrapping di una chiamata a un'altra funzione e quindi restituisce il tipo restituito della funzione di cui è stato eseguito il wrapping.

 decltype( expression )

Parametri

Parametro	Descrizione
expression	Espressione.Per ulteriori informazioni, vedere Espressioni (C++).

Valore restituito

Tipo del parametro expression.

Note

decltype l'identificatore del tipo è supportato in Visual C++ 2010 o versioni successive e può essere utilizzato con l'oggetto nativo o codice gestito.

Il compilatore utilizza le seguenti regole per determinare il tipo di expression parametro.

se expression il parametro è un identificatore o una proprietà accesso a membri di classe, decltype(expression) è il tipo di entità denominata da expression.Se non c " è tale entità o expression i nomi di parametro un insieme di funzioni in overload, il compilatore genera un messaggio di errore.
se expression il parametro è una chiamata a una funzione o di una funzione in overload di operatore, decltype(expression) è il tipo restituito della funzione.Le parentesi attorno a un operatore di overload vengono ignorate.
se expression il parametro è rvalue, decltype(expression) è il tipo di expression.se expression il parametro è lvalue, decltype(expression) viene riferimento lvalue il tipo di expression.

Nell'esempio di codice seguente viene illustrato alcuni utilizzi di decltype identificatore del tipo.Innanzitutto, si supponga di avere codificato le istruzioni seguenti.

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

A questo punto, esaminare i tipi restituiti dai quattro decltype le istruzioni nella tabella seguente.

Istruzione	Type	Note
decltype(fx());	const int&&	il riferimento rvalue a un oggetto const int.
decltype(var);	int	il tipo di variabile var.
decltype(a->x);	double	Il tipo di accesso del membro.
decltype((a->x));	const double&	Le parentesi interne determinano l'istruzione a essere valutate come espressione anziché un accesso al membro.E poiché a viene dichiarato come classe const il puntatore, il tipo è un riferimento a const double.

Decltype e automatico

utilizzare decltype digitare identificatore, insieme a auto parola chiave, dichiarare una funzione di modello che il tipo restituito dipende dai tipi degli argomenti di modello.Ad esempio, si consideri il seguente esempio di codice in cui il tipo restituito della funzione di modello dipende dai tipi degli argomenti.Nell'esempio di codice, SCONOSCIUTO il segnaposto indica che il tipo restituito non può essere specificato.

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

L'introduzione di decltype l'identificatore del tipo consente a uno sviluppatore per ottenere il tipo dell'espressione che la funzione restituisca un risultato del modello.utilizzare sintassi alternativa della dichiarazione di funzione ciò è riportato successivamente, auto parola chiave e decltype identificatore del tipo per dichiarare un oggetto tardi-specificato tipo restituito.Il tipo restituito tardi-specificato viene determinato se la dichiarazione viene compilata, anziché quando viene codificato.

Il prototipo indicato di seguito viene illustrata la sintassi per la dichiarazione di funzione alternativa.si noti che const e volatile qualificatori e throwspecifica delle eccezioni sono facoltative.function_body il segnaposto rappresenta un'istruzione composta che specifica la funzione esegue.come la migliore procedura di codifica, espressione segnaposto in decltype l'istruzione deve corrispondere all'espressione specificata da return istruzione, se presente, in function_body.

autonome_funzione(parametriscegliere)constsceglierevolatilescegliere−>decltype(espressione)throwscegliere{function_body};

Nell'esempio di codice, il tipo restituito di tardi-specificato myFunc la funzione di modello è determinata dai tipi di t e u argomenti di modello.Come la migliore procedura di codifica, nell'esempio di codice viene utilizzato anche i riferimenti rvalue e forward modello di funzione, che supportano inoltro perfetto.Per ulteriori informazioni, vedere Dichiarazione di riferimento 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 e funzioni di inoltro

Chiamate di inoltro di funzioni ad altre funzioni.Si consideri un template di funzione che inoltra gli argomenti, o i risultati di un'espressione che include gli argomenti, a un'altra funzione.Inoltre, la funzione di inoltro restituisce il risultato della chiamata a un'altra funzione.In questo scenario, il tipo restituito della funzione di inoltro deve essere uguale al tipo restituito della funzione di cui è stato eseguito il wrapping.

In questo scenario, non è possibile scrivere un'espressione appropriata del tipo senza decltype identificatore del tipo.decltype l'identificatore del tipo consente alle funzioni di inoltro generiche poiché non perda le informazioni necessarie su se una funzione restituisce un tipo di riferimento.per un esempio di codice di una funzione di inoltro, vedere il precedente myFunc esempio di funzione di modello.

Esempio

Nell'esempio di codice dichiara il tipo restituito tardi-specificato di funzione di modello Plus().Plus la funzione elabora i due operandi con operator+ overload.Di conseguenza, l'interpretazione l'operatore più (+) e il tipo restituito di Plus la funzione dipende dai tipi degli argomenti della funzione.

// 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;
}

Output

Questo esempio di codice dai seguenti risultati.

13.5

Hello, world!

Requisiti

Visual C++ 2010 o versioni successive.

Vedere anche

Riferimenti

Nomi di tipo semplice

Condividi tramite