What are some uses of decltype(auto)?

by

Return type forwarding in generic code

For non-generic code, like the initial example you gave, you can manually select to get a reference as a return type:

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

but in generic code you want to be able to perfectly forward a return type without knowing whether you are dealing with a reference or a value. decltype(auto) gives you that ability:

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

Delaying return type deduction in recursive templates

In this Q&A a few days ago, an infinite recursion during template instantiation was encountered when the return type of the template was specified as decltype(iter(Int<i-1>{})) instead of 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) is used here to delay the return type deduction after the dust of template instantiation has settled.

Other uses

You can also use decltype(auto) in other contexts, e.g. the draft Standard N3936 also states

7.1.6.4 auto specifier [dcl.spec.auto]

1 The auto and decltype(auto) type-specifiers designate a placeholder
type that will be replaced later, either by deduction from an
initializer or by explicit specification with a trailing-return-type.
The auto type-specifier is also used to signify that a lambda is a
generic lambda.

2 The placeholder type can appear with a function declarator in the decl-specifier-seq, type-specifier-seq,
conversion-function-id, or trailing-return-type, in any context where such a declarator is valid. If the function
declarator includes a trailing-return-type (8.3.5), that specifies the declared return type of the function.
If the declared return type of the function contains a placeholder type, the return type of the function is
deduced from return statements in the body of the function, if any.

The draft also contains this example of variable initialization:

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)

More Related Contents:

  1. How does generic lambda work in C++14?
  2. Arrow operator (->) in function heading
  3. Is auto as a parameter in a regular function a GCC 4.9 extension?
  4. When should I use C++14 automatic return type deduction?
  5. Why do lambda functions drop deduced return type reference by default?
  6. Use of ‘auto func(int)’ before deduction of ‘auto’ in C++14
  7. Purpose of perfect forwarding for Callable argument in invocation expression?
  8. How to implement classic sorting algorithms in modern C++?
  9. How does `void_t` work
  10. Why can I use auto on a private type?
  11. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  12. Should the trailing return type syntax style become the default for new C++11 programs? [closed]
  13. Advantages of auto in template parameters in C++17
  14. C++11: Correct std::array initialization?
  15. C++14 Variable Templates: what is their purpose? Any usage example?
  16. Pass by value vs pass by rvalue reference
  17. Does a declaration using “auto” match an extern declaration that uses a concrete type specifier?
  18. Is #pragma once part of the C++11 standard?
  19. Is there a name for this tuple-creation idiom?
  20. Difference between std::result_of and decltype
  21. What expressions yield a reference type when decltype is applied to them?
  22. Calling initializer_list constructor via make_unique/make_shared
  23. details of std::make_index_sequence and std::index_sequence
  24. ‘auto’ as a template argument placeholder for a function parameter
  25. How can I use C++14 features when building qmake projects?
  26. Is C++20 ‘char8_t’ the same as our old ‘char’?
  27. C++11 Change `auto` Lambda to a different Lambda?
  28. Directly write into char* buffer of std::string
  29. What is the status on dynarrays?
  30. Does ‘auto’ type assignments of a pointer in c++11 require ‘*’?

Leave a Comment