c++ - decltype(auto) 有哪些用途？

Question

在 c++14 中引入了 decltype(auto) 习惯用法。

通常它的用途是 允许 auto 声明在给定的表达式 上使用 decltype 规则。

搜索成语的“好”用法示例，我只能想到以下内容(通过 Scott Meyers )，即对于 函数的返回类型推导 :

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

是否还有其他示例说明此新语言功能很有用？

Answer 1

通用代码中的返回类型转发

对于非通用代码，就像您给出的初始示例一样，您可以手动选择以获取引用作为返回类型:

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

但是在 通用代码 中，您希望能够 完美地转发返回类型 而不知道您是在处理引用还是值。 decltype(auto) 为您提供了这种能力:

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

递归模板中的延迟返回类型推导

前几天在 this Q&A中，遇到了模板实例化过程中模板返回类型指定为 decltype(iter(Int<i-1>{}))而不是 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) 用于 在模板实例化尘埃落定后延迟返回类型推导 。

其他用途

您还可以在其他上下文中使用 decltype(auto)，例如标准草案 N3936 还指出

7.1.6.4 自动说明符 [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.

草案还包含这个变量初始化的例子:

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)