9 Declarations [dcl]

9.2 Specifiers [dcl.spec]

9.2.9 Type specifiers [dcl.type]

9.2.9.7 Placeholder type specifiers [dcl.spec.auto]

9.2.9.7.2 Placeholder type deduction [dcl.type.auto.deduct]

Placeholder type deduction is the process by which a type containing a placeholder type is replaced by a deduced type.

A type T containing a placeholder type, and a corresponding initializer-clause E, are determined as follows:

(2.1)
For a non-discarded return statement that occurs in a function declared with a return type that contains a placeholder type, T is the declared return type.
- (2.1.1)
  If the return statement has no operand, then E is void().
- (2.1.2)
  If the operand is a braced-init-list ([dcl.init.list]), the program is ill-formed.
- (2.1.3)
  If the operand is an expression X that is not an assignment-expression, E is (X).
  
  [Note 1:
  A comma expression ([expr.comma]) is not an assignment-expression.
  — end note]
- (2.1.4)
  Otherwise, E is the operand of the return statement.
If E has type void, T shall be either type-constraint $_{o p t}$ decltype(auto) or cv type-constraint $_{o p t}$ auto.
(2.2)
For a variable declared with a type that contains a placeholder type, T is the declared type of the variable.
- (2.2.1)
  If the initializer of the variable is a brace-or-equal-initializer of the form = initializer-clause, E is the initializer-clause.
- (2.2.2)
  If the initializer is a braced-init-list, it shall consist of a single brace-enclosed assignment-expression and E is the assignment-expression.
- (2.2.3)
  If the initializer is a parenthesized expression-list, the expression-list shall be a single assignment-expression and E is the assignment-expression.
(2.3)
For an explicit type conversion ([expr.type.conv]), T is the specified type, which shall be auto.
- (2.3.1)
  If the initializer is a braced-init-list, it shall consist of a single brace-enclosed assignment-expression and E is the assignment-expression.
- (2.3.2)
  If the initializer is a parenthesized expression-list, the expression-list shall be a single assignment-expression and E is the assignment-expression.
(2.4)
For a constant template parameter declared with a type that contains a placeholder type, T is the declared type of the constant template parameter and E is the corresponding template argument.

T shall not be an array type.

If the placeholder-type-specifier is of the form type-constraint

_{o p t}

auto, the deduced type

T^{'}

replacing T is determined using the rules for template argument deduction.

If the initialization is copy-list-initialization, a declaration of std::initializer_list shall precede ([basic.lookup.general]) the placeholder-type-specifier.

Obtain P from T by replacing the occurrence of type-constraint

_{o p t}

auto either with a new invented type template parameter U or, if the initialization is copy-list-initialization, with std::initializer_list<U>.

Deduce a value for U using the rules of template argument deduction from a function call, where P is a function template parameter type and the corresponding argument is E.

If the deduction fails, the declaration is ill-formed.

Otherwise,

T^{'}

is obtained by substituting the deduced U into P.

[Example 1: auto x1 = { 1, 2 }; // decltype(x1) is std::initializer_list<int> auto x2 = { 1, 2.0 }; // error: cannot deduce element type auto x3{ 1, 2 }; // error: not a single element auto x4 = { 3 }; // decltype(x4) is std::initializer_list<int> auto x5{ 3 }; // decltype(x5) is int — end example]

[Example 2: const auto &i = expr;

The type of i is the deduced type of the parameter u in the call f(expr) of the following invented function template: template <class U> void f(const U& u);

— end example]

If the placeholder-type-specifier is of the form type-constraint

_{o p t}

decltype(auto), T shall be the placeholder alone.

The type deduced for T is determined as described in [dcl.type.decltype], as though E had been the operand of the decltype.

[Example 3: int i; int&& f(); auto x2a(i); // decltype(x2a) is int decltype(auto) x2d(i); // decltype(x2d) is int 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) auto f1(int x) -> decltype((x)) { return (x); } // return type is int& auto f2(int x) -> decltype(auto) { return (x); } // return type is int&& — end example]

For a placeholder-type-specifier with a type-constraint, the immediately-declared constraint ([temp.param]) of the type-constraint for the type deduced for the placeholder shall be satisfied.