Especificador de tipo decltype

Artigo
02/25/2013

O decltype especificador de tipo produz o tipo de uma expressão especificada.O decltype digite especificador, juntamente com o palavra-chave auto, é útil principalmente para desenvolvedores que escrevem as bibliotecas de modelo.Use auto e decltype para declarar uma função do modelo cujo retorno tipo depende dos tipos de seus argumentos de modelo.Ou, use auto e decltype para declarar uma função do modelo que envolve uma chamada para outra função e retorna o tipo de retorno da função empacotado.

 decltype( expression )

Parâmetros

Parâmetro	Descrição
expression	Uma expressão.Para obter mais informações, consulte Expressões (C++).

Valor de retorno

O tipo da expression parâmetro.

Comentários

O decltype especificador de tipo é suportado no Visual C++ 2010 ou versões posteriores e pode ser usado com código nativo ou gerenciado.

O compilador usa as seguintes regras para determinar o tipo da expression parâmetro.

Se a expression parâmetro é um identificador ou um acesso de membro de classe, decltype(expression) é o tipo da entidade nomeada pelo expression.Se não houver nenhuma tal entidade ou o expression um conjunto de funções sobrecarregadas de nomes de parâmetro, o compilador gera uma mensagem de erro.
Se a expression parâmetro é uma chamada para uma função ou uma função de operador sobrecarregado, decltype(expression) é o tipo de retorno da função.Um operador sobrecarregado entre parênteses são ignorados.
If the expression parameter is an rvalue, decltype(expression) is the type of expression.If the expression parameter is an lvalue, decltype(expression) is an lvalue reference to the type of expression.

O exemplo de código a seguir demonstra alguns usos da decltype especificador de tipo.Primeiro, suponha que você codificou tem as seguintes instruções.

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

Em seguida, examine os tipos que são retornados por quatro decltype instruções na tabela a seguir.

Instrução	Tipo	Anotações
decltype(fx());	const int&&	Um referência de rvalue para um const int.
decltype(var);	int	O tipo de variável var.
decltype(a->x);	double	O tipo de acesso de membro.
decltype((a->x));	const double&	Os parênteses internos provocar a instrução a ser avaliada como uma expressão em vez de um acesso de membro.E porque a é declarada como uma const o tipo de ponteiro, é uma referência a const double.

Decltype e Auto

Use o decltype digite especificador, juntamente com o auto palavra-chave, para declarar uma função do modelo cujo tipo de retorno varia de acordo com os tipos de seus argumentos de modelo.Por exemplo, considere o seguinte exemplo de código na qual o tipo de retorno da função do modelo varia de acordo com os tipos dos argumentos de modelo.No exemplo de código, o desconhecido espaço reservado indica que o tipo de retorno não pode ser especificado.

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

A introdução da decltype especificador de tipo permite que um desenvolvedor obtenha o tipo da expressão que retorna a função do modelo.Use o sintaxe de declaração de função alternativos que é mostrado posteriormente, o auto palavra-chave e o decltype digite especificador para declarar um tardia especificado tipo de retorno.O tipo de retorno atrasado especificado é determinado quando a declaração é compilada, em vez de quando ele é codificado.

O protótipo a seguir ilustra a sintaxe de uma declaração de função alternativos.Observe que o const e volatile qualificadores e o throwa especificação de exceção são opcionais.O function_body espaço reservado representa uma declaração composta que especifica a função faz.Como uma melhor codificação prática, o expressão espaço reservado no decltype instrução deve corresponder a expressão especificada pelo return instrução, se houver, no function_body.

autofunction_name(parametersopt)constoptvolatileopt−>decltype(expression)throwopt{function_body};

No exemplo de código a seguir, o atraso especificado pelo tipo de retorno da myFunc modelo de função é determinado pelos tipos da t e u argumentos de modelo.Como uma melhor prática de codificação, o exemplo de código também usa referências rvalue e o forward modelo de função, que oferecem suporte a encaminhamento perfeito.Para obter mais informações, consulte Declarador de referência 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 funções de encaminhamento

Funções de encaminhamento empacote as chamadas para outras funções.Considere a possibilidade de um modelo de função que encaminha seus argumentos, ou os resultados de uma expressão que envolve esses argumentos, para outra função.Além disso, a função de encaminhamento retornará o resultado da chamada a outra função.Nesse cenário, o tipo de retorno da função encaminhamento deve ser o mesmo que o tipo de retorno da função empacotado.

Nesse cenário, você não pode gravar uma expressão do tipo apropriado sem o decltype especificador de tipo.O decltype especificador de tipo permite que as funções de encaminhamento genérico porque ele não perde informações necessárias sobre se uma função retorna um tipo de referência.Para obter um exemplo de código de uma função de encaminhamento, consulte anterior myFunc exemplo de função do modelo.

Exemplo

O exemplo de código a seguir declara o atraso especificado pelo tipo de retorno da função do modelo Plus().O Plus função processa seus dois operandos com o operator+ de sobrecarga.Conseqüentemente, a interpretação do operador mais (+) e o tipo de retorno de Plus função varia de acordo com os tipos dos argumentos de função.

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

Saída

Este exemplo de código produz os resultados a seguintes.

13.5

Hello, world!

Requisitos

Visual C++ 2010 ou versões posteriores.

Consulte também

Referência

Nomes de tipo simples

Compartilhar via