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

Files changed (1) hide show

tmp/tmp8yyv9mpw/{from.md → to.md} +185 -35

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

@@ -1,65 +1,91 @@
 #### `auto` specifier <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
-The `auto` *type-specifier* signifies that the type of a variable being
-declared shall be deduced from its initializer or that a function
-declarator shall include a *trailing-return-type*.
-The `auto` *type-specifier* may appear with a function declarator with a
-*trailing-return-type* ([[dcl.fct]]) in any context where such a
-declarator is valid.
-Otherwise, the type of the variable is deduced from its initializer. The
-name of the variable being declared shall not appear in the initializer
-expression. This use of `auto` is allowed when declaring variables in a
-block ([[stmt.block]]), in namespace scope (
-[[basic.scope.namespace]]), and in a  ([[stmt.for]]). `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*.
 ``` 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
 ```
-The `auto` 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` in a context not explicitly allowed in this
-section is ill-formed.
-Once the type of a has been determined according to  [[dcl.meaning]],
-the type of the declared variable using the is determined from the type
-of its initializer using the rules for template argument deduction. Let
-`T` be the type that has been determined for a variable identifier `d`.
-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* ([[dcl.init.list]]), with
-`std::initializer_list<U>`. The type deduced for the variable `d` is
-then the deduced `A` determined 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 for `d` is the
-corresponding argument. If the deduction fails, the declaration is
-ill-formed.
 ``` cpp
 auto x1 = { 1, 2 };         // decltype(x1) is std::initializer_list<int>
 auto x2 = { 1, 2.0 };       // error: cannot deduce element type
 ```
-If the list of declarators contains more than one declarator, the type
-of each declared variable is determined as described above. If the type
-deduced for the template parameter `U` is not the same in each
-deduction, the program is ill-formed.
 ``` cpp
 const auto &i = expr;
 ```
 The type of `i` is the deduced type of the parameter `u` in the call
@@ -67,5 +93,129 @@ The type of `i` is the deduced type of the parameter `u` in the call
 ``` cpp
 template <class U> void f(const U& u);
 ```

 #### `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
 ``` 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
+auto sum(int i) {
+  if (i == 1)
+    return i;          // sum's return type is int
+  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()
+decltype(auto) f();     // error, auto and decltype(auto) don't match
+template <typename T> auto g(T t) { return t; } // #1
+template auto g(int);                           // OK, return type is int
+template char g(char);                          // error, no matching template
+template<> auto g(double);                      // OK, forward declaration with unknown return type
+template <class T> T g(T t) { return t; } // OK, not functionally equivalent to #1
+template char g(char);                    // OK, now there is a matching template
+template auto g(float);                   // still matches #1
+void h() { return g(42); } // error, ambiguous
+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
+```

Diff to HTML by rtfpessoa