[dcl.spec.auto] - C++14 → C++17

Files changed (1) hide show

tmp/tmpv7cocn6r/{from.md → to.md} +168 -96

tmp/tmpv7cocn6r/{from.md → to.md} RENAMED Viewed

@@ -1,154 +1,116 @@
-#### `auto` specifier <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
-The `auto` and `decltype(auto)` *type-specifier*s 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.
 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* (
-[[dcl.fct]]), 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.
 If the `auto` *type-specifier* appears as one of the *decl-specifier*s
 in the *decl-specifier-seq* of a *parameter-declaration* of a
 *lambda-expression*, the lambda is a *generic lambda* (
-[[expr.prim.lambda]]).
 ``` cpp
 auto glambda = [](int i, auto a) { return i; };     // OK: a generic lambda
 ```
 The type of a variable declared using `auto` or `decltype(auto)` is
-deduced from its initializer. This use is allowed when declaring
-variables in a block ([[stmt.block]]), in namespace scope (
-[[basic.scope.namespace]]), and in a  ([[stmt.for]]). `auto` or
-`decltype(auto)` shall appear as one of the *decl-specifier*s in the
-*decl-specifier-seq* and the *decl-specifier-seq* shall be followed by
-one or more *init-declarator*s, each of which shall have a non-empty
 *initializer*. In an *initializer* of the form
 ``` cpp
 ( expression-list )
 ```
 the *expression-list* shall be a single *assignment-expression*.
 ``` cpp
 auto x = 5;                     // OK: x has type int
 const auto *v = &x, u = 6;      // OK: v has type const int*, u has type const int
 static auto y = 0.0;            // OK: y has type double
 auto int r;                     // error: auto is not a storage-class-specifier
 auto f() -> int;                // OK: f returns int
 auto g() { return 0.0; }        // OK: g returns double
 auto h();                       // OK: h's return type will be deduced when it is defined
 ```
-A placeholder type can also be used in declaring a variable in the of a
-selection statement ([[stmt.select]]) or an iteration statement (
-[[stmt.iter]]), in the in the or of a  ([[expr.new]]), in a
-*for-range-declaration*, and in declaring a static data member with a
-*brace-or-equal-initializer* that appears within the of a class
-definition ([[class.static.data]]).
 A program that uses `auto` or `decltype(auto)` in a context not
 explicitly allowed in this section is ill-formed.
-When a variable declared using a placeholder type is initialized, or a
-`return` statement occurs in a function declared with a return type that
-contains a placeholder type, the deduced return type or variable type is
-determined from the type of its initializer. In the case of a `return`
-with no operand, the initializer is considered to be `void()`. Let `T`
-be the declared type of the variable or return type of the function. If
-the placeholder is the `auto` *type-specifier*, the deduced type is
-determined using the rules for template argument deduction. If the
-deduction is for a `return` statement and the initializer is a
-*braced-init-list* ([[dcl.init.list]]), the program is ill-formed.
-Otherwise, obtain `P` from `T` by replacing the occurrences of `auto`
-with either a new invented type template parameter `U` or, if the
-initializer is a *braced-init-list*, with `std::initializer_list<U>`.
-Deduce a value for `U` using the rules of template argument deduction
-from a function call ([[temp.deduct.call]]), where `P` is a function
-template parameter type and the initializer is the corresponding
-argument. If the deduction fails, the declaration is ill-formed.
-Otherwise, the type deduced for the variable or return type is obtained
-by substituting the deduced `U` into `P`.
-``` cpp
-auto x1 = { 1, 2 };         // decltype(x1) is std::initializer_list<int>
-auto x2 = { 1, 2.0 };       // error: cannot deduce element type
-```
-``` cpp
-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:
-``` cpp
-template <class U> void f(const U& u);
-```
-If the placeholder is the `decltype(auto)` *type-specifier*, the
-declared type of the variable or return type of the function shall be
-the placeholder alone. The type deduced for the variable or return type
-is determined as described in  [[dcl.type.simple]], as though the
-initializer had been the operand of the `decltype`.
-``` cpp
-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)
-```
 If the *init-declarator-list* contains more than one *init-declarator*,
 they shall all form declarations of variables. The type of each declared
-variable is determined as described above, and if the type that replaces
-the placeholder type is not the same in each deduction, the program is
-ill-formed.
 ``` cpp
 auto x = 5, *y = &x;            // OK: auto is int
 auto a = 5, b = { 1, 2 };       // error: different types for auto
 ```
 If a function with a declared return type that contains a placeholder
-type has multiple `return` statements, the return type is deduced for
-each `return` statement. If the type deduced is not the same in each
-deduction, the program is ill-formed.
 If a function with a declared return type that uses a placeholder type
-has no `return` statements, the return type is deduced as though from a
-`return` statement with no operand at the closing brace of the function
-body.
 ``` cpp
 auto  f() { }                   // OK, return type is void
 auto* g() { }                   // error, cannot deduce auto* from void()
 ```
 If the type of an entity with an undeduced placeholder type is needed to
 determine the type of an expression, the program is ill-formed. Once a
-`return` statement has been seen in a function, however, the return type
-deduced from that statement can be used in the rest of the function,
-including in other `return` statements.
 ``` cpp
 auto n = n;                     // error, n's type is unknown
 auto f();
 void g() { &f; }                // error, f's return type is unknown
@@ -158,30 +120,41 @@ auto sum(int i) {
   else
     return sum(i-1)+i;          // OK, sum's return type has been deduced
 }
 ```
 Return type deduction for a function template with a placeholder in its
 declared type occurs when the definition is instantiated even if the
 function body contains a `return` statement with a non-type-dependent
-operand. Therefore, any use of a specialization of the function template
-will cause an implicit instantiation. Any errors that arise from this
-instantiation are not in the immediate context of the function type and
-can result in the program being ill-formed.
 ``` cpp
 template <class T> auto f(T t) { return t; }    // return type deduced at instantiation time
 typedef decltype(f(1)) fint_t;                  // instantiates f<int> to deduce return type
 template<class T> auto f(T* t) { return *t; }
 void g() { int (*p)(int*) = &f; }               // instantiates both fs to determine return types,
                                                 // chooses second
 ```
 Redeclarations or specializations of a function or function template
 with a declared return type that uses a placeholder type shall also use
 that placeholder, not a deduced type.
 ``` cpp
 auto f();
 auto f() { return 42; }                         // return type is int
 auto f();                                       // OK
 int f();                                        // error, cannot be overloaded with auto f()
@@ -202,20 +175,119 @@ template <typename T> struct A {
   friend T frf(T);
 };
 auto frf(int i) { return i; }                   // not a friend of A<int>
 ```
 A function declared with a return type that uses a placeholder type
 shall not be `virtual` ([[class.virtual]]).
 An explicit instantiation declaration ([[temp.explicit]]) does not
 cause the instantiation of an entity declared using a placeholder type,
 but it also does not prevent that entity from being instantiated as
 needed to determine its type.
 ``` cpp
 template <typename T> auto f(T t) { return t; }
 extern template auto f(int);    // does not instantiate f<int>
 int (*p)(int) = f;              // instantiates f<int> to determine its return type, but an explicit
                                 // instantiation definition is still required somewhere in the program
 ```

+#### The `auto` specifier <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
+The `auto` and `decltype(auto)` *type-specifier*s are used to designate
+a placeholder type that will be replaced later by deduction from an
+initializer. The `auto` *type-specifier* is also used to introduce a
+function type having a *trailing-return-type* or to signify that a
+lambda is a generic lambda ([[expr.prim.lambda.closure]]). The `auto`
+*type-specifier* is also used to introduce a structured binding
+declaration ([[dcl.struct.bind]]).
 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* (
+[[dcl.fct]]), that *trailing-return-type* specifies the declared return
+type of the function. Otherwise, the function declarator shall declare a
+function. If the declared return type of the function contains a
+placeholder type, the return type of the function is deduced from
+non-discarded `return` statements, if any, in the body of the function (
+[[stmt.if]]).
 If the `auto` *type-specifier* appears as one of the *decl-specifier*s
 in the *decl-specifier-seq* of a *parameter-declaration* of a
 *lambda-expression*, the lambda is a *generic lambda* (
+[[expr.prim.lambda.closure]]).
+[*Example 1*:
 ``` cpp
 auto glambda = [](int i, auto a) { return i; };     // OK: a generic lambda
 ```
+— *end example*]
 The type of a variable declared using `auto` or `decltype(auto)` is
+deduced from its initializer. This use is allowed in an initializing
+declaration ([[dcl.init]]) of a variable. `auto` or `decltype(auto)`
+shall appear as one of the *decl-specifier*s in the *decl-specifier-seq*
+and the *decl-specifier-seq* shall be followed by one or more
+*declarator*s, each of which shall be followed by a non-empty
 *initializer*. In an *initializer* of the form
 ``` cpp
 ( expression-list )
 ```
 the *expression-list* shall be a single *assignment-expression*.
+[*Example 2*:
 ``` cpp
 auto x = 5;                     // OK: x has type int
 const auto *v = &x, u = 6;      // OK: v has type const int*, u has type const int
 static auto y = 0.0;            // OK: y has type double
 auto int r;                     // error: auto is not a storage-class-specifier
 auto f() -> int;                // OK: f returns int
 auto g() { return 0.0; }        // OK: g returns double
 auto h();                       // OK: h's return type will be deduced when it is defined
 ```
+— *end example*]
+A placeholder type can also be used in the *type-specifier-seq* in the
+*new-type-id* or *type-id* of a *new-expression* ([[expr.new]]) and as
+a *decl-specifier* of the *parameter-declaration*'s *decl-specifier-seq*
+in a *template-parameter* ([[temp.param]]).
 A program that uses `auto` or `decltype(auto)` in a context not
 explicitly allowed in this section is ill-formed.
 If the *init-declarator-list* contains more than one *init-declarator*,
 they shall all form declarations of variables. The type of each declared
+variable is determined by placeholder type deduction (
+[[dcl.type.auto.deduct]]), and if the type that replaces the placeholder
+type is not the same in each deduction, the program is ill-formed.
+[*Example 3*:
 ``` cpp
 auto x = 5, *y = &x;            // OK: auto is int
 auto a = 5, b = { 1, 2 };       // error: different types for auto
 ```
+— *end example*]
 If a function with a declared return type that contains a placeholder
+type has multiple non-discarded `return` statements, the return type is
+deduced for each such `return` statement. If the type deduced is not the
+same in each deduction, the program is ill-formed.
 If a function with a declared return type that uses a placeholder type
+has no non-discarded `return` statements, the return type is deduced as
+though from a `return` statement with no operand at the closing brace of
+the function body.
+[*Example 4*:
 ``` cpp
 auto  f() { }                   // OK, return type is void
 auto* g() { }                   // error, cannot deduce auto* from void()
 ```
+— *end example*]
 If the type of an entity with an undeduced placeholder type is needed to
 determine the type of an expression, the program is ill-formed. Once a
+non-discarded `return` statement has been seen in a function, however,
+the return type deduced from that statement can be used in the rest of
+the function, including in other `return` statements.
+[*Example 5*:
 ``` cpp
 auto n = n;                     // error, n's type is unknown
 auto f();
 void g() { &f; }                // error, f's return type is unknown
   else
     return sum(i-1)+i;          // OK, sum's return type has been deduced
 }
 ```
+— *end example*]
 Return type deduction for a function template with a placeholder in its
 declared type occurs when the definition is instantiated even if the
 function body contains a `return` statement with a non-type-dependent
+operand.
+[*Note 1*: Therefore, any use of a specialization of the function
+template will cause an implicit instantiation. Any errors that arise
+from this instantiation are not in the immediate context of the function
+type and can result in the program being ill-formed (
+[[temp.deduct]]). — *end note*]
+[*Example 6*:
 ``` cpp
 template <class T> auto f(T t) { return t; }    // return type deduced at instantiation time
 typedef decltype(f(1)) fint_t;                  // instantiates f<int> to deduce return type
 template<class T> auto f(T* t) { return *t; }
 void g() { int (*p)(int*) = &f; }               // instantiates both fs to determine return types,
                                                 // chooses second
 ```
+— *end example*]
 Redeclarations or specializations of a function or function template
 with a declared return type that uses a placeholder type shall also use
 that placeholder, not a deduced type.
+[*Example 7*:
 ``` cpp
 auto f();
 auto f() { return 42; }                         // return type is int
 auto f();                                       // OK
 int f();                                        // error, cannot be overloaded with auto f()
   friend T frf(T);
 };
 auto frf(int i) { return i; }                   // not a friend of A<int>
 ```
+— *end example*]
 A function declared with a return type that uses a placeholder type
 shall not be `virtual` ([[class.virtual]]).
 An explicit instantiation declaration ([[temp.explicit]]) does not
 cause the instantiation of an entity declared using a placeholder type,
 but it also does not prevent that entity from being instantiated as
 needed to determine its type.
+[*Example 8*:
 ``` cpp
 template <typename T> auto f(T t) { return t; }
 extern template auto f(int);    // does not instantiate f<int>
 int (*p)(int) = f;              // instantiates f<int> to determine its return type, but an explicit
                                 // instantiation definition is still required somewhere in the program
 ```
+— *end example*]
+##### Placeholder type deduction <a id="dcl.type.auto.deduct">[[dcl.type.auto.deduct]]</a>
+*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 `e`, are determined as follows:
+- 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 and `e` is the operand of the `return`
+  statement. If the `return` statement has no operand, then `e` is
+  `void()`;
+- for a variable declared with a type that contains a placeholder type,
+  `T` is the declared type of the variable and `e` is the initializer.
+  If the initialization is direct-list-initialization, the initializer
+  shall be a *braced-init-list* containing only a single
+  *assignment-expression* and `e` is the *assignment-expression*;
+- for a non-type template parameter declared with a type that contains a
+  placeholder type, `T` is the declared type of the non-type template
+  parameter and `e` is the corresponding template argument.
+In the case of a `return` statement with no operand or with an operand
+of type `void`, `T` shall be either `decltype(auto)` or cv `auto`.
+If the deduction is for a `return` statement and `e` is a
+*braced-init-list* ([[dcl.init.list]]), the program is ill-formed.
+If the placeholder is the `auto` *type-specifier*, the deduced type T'
+replacing `T` is determined using the rules for template argument
+deduction. Obtain `P` from `T` by replacing the occurrences of `auto`
+with either 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 (
+[[temp.deduct.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 9*:
+``` cpp
+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 10*:
+``` cpp
+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:
+``` cpp
+template <class U> void f(const U& u);
+```
+— *end example*]
+If the placeholder is the `decltype(auto)` *type-specifier*, `T` shall
+be the placeholder alone. The type deduced for `T` is determined as
+described in  [[dcl.type.simple]], as though `e` had been the operand of
+the `decltype`.
+[*Example 11*:
+``` cpp
+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)
+```
+— *end example*]

Diff to HTML by rtfpessoa