Quais são alguns usos do decltype (auto)?

No c ++ 14, o decltype(auto)idioma é introduzido.

Normalmente, seu uso é permitir que as autodeclarações usem as decltyperegras na expressão especificada .

Procurando exemplos de uso "bom" do idioma, só consigo pensar em coisas como as seguintes (de Scott Meyers ), especificamente para dedução do tipo de retorno de uma função :

template<typename ContainerType, typename IndexType>                // C++14
decltype(auto) grab(ContainerType&& container, IndexType&& index)
{
  authenticateUser();
  return std::forward<ContainerType>(container)[std::forward<IndexType>(index)];
}

Existem outros exemplos em que esse novo recurso de idioma é útil?

Encaminhamento de tipo de retorno em código genérico

Para código não genérico, como o exemplo inicial que você deu, você pode selecionar manualmente para obter uma referência como um tipo de retorno:

auto const& Example(int const& i) 
{ 
    return i; 
}

mas no código genérico você deseja encaminhar perfeitamente um tipo de retorno sem saber se está lidando com uma referência ou um valor. decltype(auto)lhe dá essa capacidade:

template<class Fun, class... Args>
decltype(auto) Example(Fun fun, Args&&... args) 
{ 
    return fun(std::forward<Args>(args)...); 
}

Atraso na dedução do tipo de retorno em modelos recursivos

Nestas perguntas e respostas , há alguns dias, uma recursão infinita durante a instanciação do modelo foi encontrada quando o tipo de retorno do modelo foi especificado como em decltype(iter(Int<i-1>{}))vez de decltype(auto).

template<int i> 
struct Int {};

constexpr auto iter(Int<0>) -> Int<0>;

template<int i>
constexpr auto iter(Int<i>) -> decltype(auto) 
{ return iter(Int<i-1>{}); }

int main() { decltype(iter(Int<10>{})) a; }

decltype(auto)é usado aqui para atrasar a dedução do tipo de retorno após a poeira da instanciação do modelo.

Outros usos

Você também pode usar decltype(auto)em outros contextos, por exemplo, o rascunho da norma N3936 também declara

7.1.6.4 especificador automático [dcl.spec.auto]

1 Os especificadores de tipo autoe decltype(auto)designam um tipo de espaço reservado que será substituído posteriormente, por dedução de um inicializador ou por especificação explícita com um tipo de retorno à direita. O autoespecificador de tipo também é usado para significar que um lambda é um lambda genérico.

2 O tipo de espaço reservado pode aparecer com um declarador de função no decl-specifier-seq, type-specifier-seq, conversion-id da função ou tipo de retorno à direita, em qualquer contexto em que esse declarador seja válido . Se o declarador da função incluir um tipo de retorno à direita (8.3.5), isso especifica o tipo de retorno declarado da função. Se o tipo de retorno declarado da função contiver um tipo de espaço reservado, o tipo de retorno da função será deduzido das instruções de retorno no corpo da função, se houver.

O rascunho também contém este exemplo de inicialização de variável:

int i;
int&& f();
auto x3a = i;                  // decltype(x3a) is int
decltype(auto) x3d = i;        // decltype(x3d) is int
auto x4a = (i);                // decltype(x4a) is int
decltype(auto) x4d = (i);      // decltype(x4d) is int&
auto x5a = f();                // decltype(x5a) is int
decltype(auto) x5d = f();      // decltype(x5d) is int&&
auto x6a = { 1, 2 };           // decltype(x6a) is std::initializer_list<int>
decltype(auto) x6d = { 1, 2 }; // error, { 1, 2 } is not an expression
auto *x7a = &i;                // decltype(x7a) is int*
decltype(auto)*x7d = &i;       // error, declared type is not plain decltype(auto)

Citando coisas daqui :

• decltype(auto)é útil principalmente para deduzir o tipo de retorno de funções de encaminhamento e wrappers similares , onde você deseja que o tipo “rastreie” exatamente alguma expressão que você está chamando.

• Por exemplo, dadas as funções abaixo:

   string  lookup1();
   string& lookup2();

• No C ++ 11, poderíamos escrever as seguintes funções de wrapper que lembram de preservar a referência do tipo de retorno:

   string  look_up_a_string_1() { return lookup1(); }
   string& look_up_a_string_2() { return lookup2(); }

• No C ++ 14, podemos automatizar isso:

   decltype(auto) look_up_a_string_1() { return lookup1(); }
   decltype(auto) look_up_a_string_2() { return lookup2(); }

• No entanto, decltype(auto)não se destina a ser um recurso amplamente usado além disso.

• Em particular, embora possa ser usado para declarar variáveis ​​locais , isso provavelmente é apenas um antipadrão, já que a referência de uma variável local não deve depender da expressão de inicialização.

• Além disso, é sensível à forma como você escreve a declaração de retorno.

• Por exemplo, as duas funções abaixo têm diferentes tipos de retorno:

   decltype(auto) look_up_a_string_1() { auto str = lookup1(); return str; }
   decltype(auto) look_up_a_string_2() { auto str = lookup2(); return(str); }

• O primeiro retorna string, o segundo retorna string&, que é uma referência à variável local str.

A partir da proposta, você pode ver mais usos pretendidos.