[dcl.type] - C++11 → C++14

Files changed (1) hide show

tmp/tmp27w_192y/{from.md → to.md} +220 -60

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

@@ -46,25 +46,27 @@ exceptions to this rule are the following:
   or `int`.
 - `short` or `long` can be combined with `int`.
 - `long` can be combined with `double`.
 - `long` can be combined with `long`.
-At least one *type-specifier* that is not a *cv-qualifier* is required
-in a declaration unless it declares a constructor, destructor or
-conversion function.[^4] A *type-specifier-seq* shall not define a class
-or enumeration unless it appears in the *type-id* of an
 *alias-declaration* ([[dcl.typedef]]) that is not the *declaration* of
 a *template-declaration*.
 *enum-specifier*s, *class-specifier*s, and *typename-specifier*s are
-discussed in [[dcl.enum]], [[class]], and [[temp.res]], respectively.
-The remaining *type-specifier*s are discussed in the rest of this
-section.
 #### The *cv-qualifiers* <a id="dcl.type.cv">[[dcl.type.cv]]</a>
-There are two *cv-qualifiers*, `const` and `volatile`. If a
 *cv-qualifier* appears in a *decl-specifier-seq*, the
 *init-declarator-list* of the declaration shall not be empty.
 [[basic.type.qualifier]] and [[dcl.fct]] describe how cv-qualifiers
 affect object and function types. Redundant cv-qualifications are
 ignored. For example, these could be introduced by typedefs.
@@ -122,19 +124,22 @@ y.x.j++;                        // ill-formed: const-qualified member modified
 Y* p = const_cast<Y*>(&y);      // cast away const-ness of y
 p->x.i = 99;                    // well-formed: mutable member can be modified
 p->x.j = 99;                    // undefined: modifies a const member
 ```
-If an attempt is made to refer to an object defined with a
-volatile-qualified type through the use of a glvalue with a
-non-volatile-qualified type, the program behavior is undefined.
 `volatile` is a hint to the implementation to avoid aggressive
 optimization involving the object because the value of the object might
-be changed by means undetectable by an implementation. See
-[[intro.execution]] for detailed semantics. In general, the semantics of
-`volatile` are intended to be the same in C++as they are in C.
 #### Simple type specifiers <a id="dcl.type.simple">[[dcl.type.simple]]</a>
 The simple type specifiers are
@@ -168,18 +173,19 @@ type-name:
 ```
 ``` bnf
 decltype-specifier:
   'decltype' '(' expression ')'
 ```
 The `auto` specifier is a placeholder for a type to be deduced (
 [[dcl.spec.auto]]). The other *simple-type-specifier*s specify either a
-previously-declared user-defined type or one of the fundamental types (
-[[basic.fundamental]]). Table  [[tab:simple.type.specifiers]] summarizes
-the valid combinations of *simple-type-specifier*s and the types they
-specify.
 **Table: *simple-type-specifier*{s} and the types they specify** <a id="tab:simple.type.specifiers">[tab:simple.type.specifiers]</a>
 |                        |                                        |
 | ---------------------- | -------------------------------------- |
@@ -223,16 +229,16 @@ specify.
 | decltype(*expression*) | the type as defined below              |
 When multiple *simple-type-specifiers* are allowed, they can be freely
 intermixed with other *decl-specifiers* in any order. It is
-implementation-defined whether objects of `char` type and certain
-bit-fields ([[class.bit]]) are represented as signed or unsigned
-quantities. The `signed` specifier forces `char` objects and bit-fields
-to be signed; it is redundant in other contexts.
-The type denoted by `decltype(e)` is defined as follows:
 - if `e` is an unparenthesized *id-expression* or an unparenthesized
   class member access ([[expr.ref]]), `decltype(e)` is the type of the
   entity named by `e`. If there is no such entity, or if `e` names a set
   of overloaded functions, the program is ill-formed;
@@ -248,16 +254,19 @@ The operand of the `decltype` specifier is an unevaluated operand
 ``` cpp
 const int&& foo();
 int i;
 struct A { double x; };
 const A* a = new A();
-decltype(foo()) x1 = i;         // type is const int&&
 decltype(i) x2;                 // type is int
 decltype(a->x) x3;              // type is double
 decltype((a->x)) x4 = x3;       // type is const double&
 ```
 in the case where the operand of a *decltype-specifier* is a function
 call and the return type of the function is a class type, a special
 rule ([[expr.call]]) ensures that the return type is not required to be
 complete (as it would be if the call appeared in a sub-expression or
 outside of a *decltype-specifier*). In this context, the common purpose
@@ -300,11 +309,12 @@ void r() {
 #### Elaborated type specifiers <a id="dcl.type.elab">[[dcl.type.elab]]</a>
 ``` bnf
 elaborated-type-specifier:
     class-key attribute-specifier-seqₒₚₜ nested-name-specifierₒₚₜ identifier
-    class-key nested-name-specifierₒₚₜ 'template'ₒₚₜ simple-template-id
     'enum' nested-name-specifierₒₚₜ identifier
 ```
 An *attribute-specifier-seq* shall not appear in an
 *elaborated-type-specifier* unless the latter is the sole constituent of
@@ -360,68 +370,94 @@ enum class E { a, b };
 enum E x = E::a;                // OK
 ```
 #### `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
@@ -429,5 +465,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);
 ```

   or `int`.
 - `short` or `long` can be combined with `int`.
 - `long` can be combined with `double`.
 - `long` can be combined with `long`.
+Except in a declaration of a constructor, destructor, or conversion
+function, at least one *type-specifier* that is not a *cv-qualifier*
+shall appear in a complete *type-specifier-seq* or a complete
+*decl-specifier-seq*.[^3] A *type-specifier-seq* shall not define a
+class or enumeration unless it appears in the *type-id* of an
 *alias-declaration* ([[dcl.typedef]]) that is not the *declaration* of
 a *template-declaration*.
 *enum-specifier*s, *class-specifier*s, and *typename-specifier*s are
+discussed in [[dcl.enum]], Clause  [[class]], and [[temp.res]],
+respectively. The remaining *type-specifier*s are discussed in the rest
+of this section.
 #### The *cv-qualifiers* <a id="dcl.type.cv">[[dcl.type.cv]]</a>
+There are two *cv-qualifiers*, `const` and `volatile`. Each
+*cv-qualifier* shall appear at most once in a *cv-qualifier-seq*. If a
 *cv-qualifier* appears in a *decl-specifier-seq*, the
 *init-declarator-list* of the declaration shall not be empty.
 [[basic.type.qualifier]] and [[dcl.fct]] describe how cv-qualifiers
 affect object and function types. Redundant cv-qualifications are
 ignored. For example, these could be introduced by typedefs.
 Y* p = const_cast<Y*>(&y);      // cast away const-ness of y
 p->x.i = 99;                    // well-formed: mutable member can be modified
 p->x.j = 99;                    // undefined: modifies a const member
 ```
+What constitutes an access to an object that has volatile-qualified type
+is implementation-defined. If an attempt is made to refer to an object
+defined with a volatile-qualified type through the use of a glvalue with
+a non-volatile-qualified type, the program behavior is undefined.
 `volatile` is a hint to the implementation to avoid aggressive
 optimization involving the object because the value of the object might
+be changed by means undetectable by an implementation. Furthermore, for
+some implementations, `volatile` might indicate that special hardware
+instructions are required to access the object. See  [[intro.execution]]
+for detailed semantics. In general, the semantics of `volatile` are
+intended to be the same in C++as they are in C.
 #### Simple type specifiers <a id="dcl.type.simple">[[dcl.type.simple]]</a>
 The simple type specifiers are
 ```
 ``` bnf
 decltype-specifier:
   'decltype' '(' expression ')'
+  'decltype' '(' 'auto' ')'
 ```
 The `auto` specifier is a placeholder for a type to be deduced (
 [[dcl.spec.auto]]). The other *simple-type-specifier*s specify either a
+previously-declared type, a type determined from an expression, or one
+of the fundamental types ([[basic.fundamental]]). Table
+[[tab:simple.type.specifiers]] summarizes the valid combinations of
+*simple-type-specifier*s and the types they specify.
 **Table: *simple-type-specifier*{s} and the types they specify** <a id="tab:simple.type.specifiers">[tab:simple.type.specifiers]</a>
 |                        |                                        |
 | ---------------------- | -------------------------------------- |
 | decltype(*expression*) | the type as defined below              |
 When multiple *simple-type-specifiers* are allowed, they can be freely
 intermixed with other *decl-specifiers* in any order. It is
+implementation-defined whether objects of `char` type are represented as
+signed or unsigned quantities. The `signed` specifier forces `char`
+objects to be signed; it is redundant in other contexts.
+For an expression `e`, the type denoted by `decltype(e)` is defined as
+follows:
 - if `e` is an unparenthesized *id-expression* or an unparenthesized
   class member access ([[expr.ref]]), `decltype(e)` is the type of the
   entity named by `e`. If there is no such entity, or if `e` names a set
   of overloaded functions, the program is ill-formed;
 ``` cpp
 const int&& foo();
 int i;
 struct A { double x; };
 const A* a = new A();
+decltype(foo()) x1 = 0;         // type is const int&&
 decltype(i) x2;                 // type is int
 decltype(a->x) x3;              // type is double
 decltype((a->x)) x4 = x3;       // type is const double&
 ```
+The rules for determining types involving `decltype(auto)` are specified
+in  [[dcl.spec.auto]].
 in the case where the operand of a *decltype-specifier* is a function
 call and the return type of the function is a class type, a special
 rule ([[expr.call]]) ensures that the return type is not required to be
 complete (as it would be if the call appeared in a sub-expression or
 outside of a *decltype-specifier*). In this context, the common purpose
 #### Elaborated type specifiers <a id="dcl.type.elab">[[dcl.type.elab]]</a>
 ``` bnf
 elaborated-type-specifier:
     class-key attribute-specifier-seqₒₚₜ nested-name-specifierₒₚₜ identifier
+    class-key simple-template-id
+    class-key nested-name-specifier 'template'ₒₚₜ simple-template-id
     'enum' nested-name-specifierₒₚₜ identifier
 ```
 An *attribute-specifier-seq* shall not appear in an
 *elaborated-type-specifier* unless the latter is the sole constituent of
 enum E x = E::a;                // OK
 ```
 #### `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