[temp.spec] - C++11 → C++14

Files changed (1) hide show

tmp/tmpsk_2_auf/{from.md → to.md} +141 -107

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

@@ -86,18 +86,19 @@ instantiated ([[temp.explicit]]) or explicitly specialized (
 [[temp.expl.spec]]), the class template specialization is implicitly
 instantiated when the specialization is referenced in a context that
 requires a completely-defined object type or when the completeness of
 the class type affects the semantics of the program. The implicit
 instantiation of a class template specialization causes the implicit
-instantiation of the declarations, but not of the definitions or default
-arguments, of the class member functions, member classes, scoped member
-enumerations, static data members and member templates; and it causes
-the implicit instantiation of the definitions of unscoped member
-enumerations and member anonymous unions. However, for the purpose of
-determining whether an instantiated redeclaration of a member is valid
-according to  [[class.mem]], a declaration that corresponds to a
-definition in the template is considered to be a definition.
 ``` cpp
 template<class T, class U>
 struct Outer {
   template<class X, class Y> struct Inner;
@@ -152,10 +153,17 @@ void h() {
 ```
 Nothing in this example requires `class` `Z<double>`, `Z<int>::g()`, or
 `Z<char>::f()` to be implicitly instantiated.
 A class template specialization is implicitly instantiated if the class
 type is used in a context that requires a completely-defined object type
 or if the completeness of the class type might affect the semantics of
 the program. In particular, if the semantics of an expression depend on
 the member or base class lists of a class template specialization, the
@@ -215,28 +223,28 @@ data members of that class to be implicitly instantiated.
 If a function template or a member function template specialization is
 used in a way that involves overload resolution, a declaration of the
 specialization is implicitly instantiated ([[temp.over]]).
 An implementation shall not implicitly instantiate a function template,
-a member template, a non-virtual member function, a member class, or a
-static data member of a class template that does not require
-instantiation. It is unspecified whether or not an implementation
-implicitly instantiates a virtual member function of a class template if
-the virtual member function would not otherwise be instantiated. The use
-of a template specialization in a default argument shall not cause the
-template to be implicitly instantiated except that a class template may
-be instantiated where its complete type is needed to determine the
-correctness of the default argument. The use of a default argument in a
-function call causes specializations in the default argument to be
-implicitly instantiated.
-Implicitly instantiated class and function template specializations are
-placed in the namespace where the template is defined. Implicitly
-instantiated specializations for members of a class template are placed
-in the namespace where the enclosing class template is defined.
-Implicitly instantiated member templates are placed in the namespace
-where the enclosing class or class template is defined.
 ``` cpp
 namespace N {
   template<class T> class List {
   public:
@@ -263,13 +271,16 @@ If a function template `f` is called in a way that requires a default
 argument to be used, the dependent names are looked up, the semantics
 constraints are checked, and the instantiation of any template used in
 the default argument is done as if the default argument had been an
 initializer used in a function template specialization with the same
 scope, the same template parameters and the same access as that of the
-function template `f` used at that point. This analysis is called
-*default argument instantiation*. The instantiated default argument is
-then used as the argument of `f`.
 Each default argument is instantiated independently.
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
@@ -283,10 +294,19 @@ void g(A a, A b, A c) {
   f(a, b);          // default argument z = zdef(T()) instantiated
   f(a);             // ill-formed; ydef is not declared
 }
 ```
 [[temp.point]] defines the point of instantiation of a template
 specialization.
 There is an implementation-defined quantity that specifies the limit on
 the total depth of recursive instantiations, which could involve more
@@ -302,16 +322,17 @@ template<class T> class X {
 };
 ```
 ### Explicit instantiation <a id="temp.explicit">[[temp.explicit]]</a>
-A class, a function or member template specialization can be explicitly
-instantiated from its template. A member function, member class or
-static data member of a class template can be explicitly instantiated
-from the member definition associated with its class template. An
-explicit instantiation of a function template or member function of a
-class template shall not use the `inline` or `constexpr` specifiers.
 The syntax for explicit instantiation is:
 ``` bnf
 explicit-instantiation:
@@ -331,17 +352,18 @@ a *template-name* or *operator-function-id*. The declaration may declare
 a *qualified-id*, in which case the *unqualified-id* of the
 *qualified-id* must be a *template-id*. If the explicit instantiation is
 for a member function, a member class or a static data member of a class
 template specialization, the name of the class template specialization
 in the *qualified-id* for the member name shall be a
-*simple-template-id*. An explicit instantiation shall appear in an
-enclosing namespace of its template. If the name declared in the
-explicit instantiation is an unqualified name, the explicit
-instantiation shall appear in the namespace where its template is
-declared or, if that namespace is inline ([[namespace.def]]), any
-namespace from its enclosing namespace set. Regarding qualified names in
-declarators, see  [[dcl.meaning]].
 ``` cpp
 template<class T> class Array { void mf(); };
 template class Array<char>;
 template void Array<int>::mf();
@@ -353,35 +375,36 @@ namespace N {
   template<class T> void f(T&) { }
 }
 template void N::f<int>(int&);
 ```
-A declaration of a function template, a member function or static data
-member of a class template, or a member function template of a class or
-class template shall precede an explicit instantiation of that entity. A
-definition of a class template, a member class of a class template, or a
-member class template of a class or class template shall precede an
-explicit instantiation of that entity unless the explicit instantiation
-is preceded by an explicit specialization of the entity with the same
-template arguments. If the *declaration* of the explicit instantiation
-names an implicitly-declared special member function (Clause
-[[special]]), the program is ill-formed.
 For a given set of template arguments, if an explicit instantiation of a
 template appears after a declaration of an explicit specialization for
 that template, the explicit instantiation has no effect. Otherwise, for
 an explicit instantiation definition the definition of a function
-template, a member function template, or a member function or static
-data member of a class template shall be present in every translation
-unit in which it is explicitly instantiated.
-An explicit instantiation of a class or function template specialization
-is placed in the namespace in which the template is defined. An explicit
-instantiation for a member of a class template is placed in the
-namespace where the enclosing class template is defined. An explicit
-instantiation for a member template is placed in the namespace where the
-enclosing class or class template is defined.
 ``` cpp
 namespace N {
   template<class T> class Y { void mf() { } };
 }
@@ -412,28 +435,31 @@ template void sort<>(Array<int>&);
 ```
 An explicit instantiation that names a class template specialization is
 also an explicit instantiation of the same kind (declaration or
 definition) of each of its members (not including members inherited from
-base classes) that has not been previously explicitly specialized in the
-translation unit containing the explicit instantiation, except as
-described below. In addition, it will typically be an explicit
-instantiation of certain implementation-dependent data about the class.
 An explicit instantiation definition that names a class template
 specialization explicitly instantiates the class template specialization
 and is an explicit instantiation definition of only those members that
 have been defined at the point of instantiation.
-Except for inline functions and class template specializations, explicit
-instantiation declarations have the effect of suppressing the implicit
-instantiation of the entity to which they refer. The intent is that an
-inline function that is the subject of an explicit instantiation
-declaration will still be implicitly instantiated when odr-used (
-[[basic.def.odr]]) so that the body can be considered for inlining, but
-that no out-of-line copy of the inline function would be generated in
-the translation unit.
 If an entity is the subject of both an explicit instantiation
 declaration and an explicit instantiation definition in the same
 translation unit, the definition shall follow the declaration. An entity
 that is the subject of an explicit instantiation declaration and that is
@@ -469,10 +495,11 @@ template int g<int>(int);       // OK even though &p isn't an int.
 An explicit specialization of any of the following:
 - function template
 - class template
 - member function of a class template
 - static data member of a class template
 - member class of a class template
 - member enumeration of a class template
 - member class template of a class or class template
@@ -510,33 +537,34 @@ enclosing namespace of the template, or, if the namespace is inline (
 [[namespace.def]]), any namespace from its enclosing namespace set. Such
 a declaration may also be a definition. If the declaration is not a
 definition, the specialization may be defined later (
 [[namespace.memdef]]).
-A declaration of a function template or class template being explicitly
-specialized shall precede the declaration of the explicit
-specialization. A declaration, but not a definition of the template is
-required. The definition of a class or class template shall precede the
-declaration of an explicit specialization for a member template of the
-class or class template.
 ``` cpp
 template<> class X<int> { /* ... */ };          // error: X not a template
 template<class T> class X;
 template<> class X<char*> { /* ... */ };        // OK: X is a template
 ```
 A member function, a member function template, a member class, a member
-enumeration, a member class template, or a static data member of a class
-template may be explicitly specialized for a class specialization that
-is implicitly instantiated; in this case, the definition of the class
-template shall precede the explicit specialization for the member of the
-class template. If such an explicit specialization for the member of a
-class template names an implicitly-declared special member function
-(Clause  [[special]]), the program is ill-formed.
 A member of an explicitly specialized class is not implicitly
 instantiated from the member declaration of the class template; instead,
 the member of the class template specialization shall itself be
 explicitly defined if its definition is required. In this case, the
@@ -628,31 +656,33 @@ template<class T> struct A {
 };
 template<> enum A<int>::E : int { eint };         // OK
 template<> enum class A<int>::S : int { sint };   // OK
 template<class T> enum A<T>::E : T { eT };
 template<class T> enum class A<T>::S : T { sT };
-template<> enum A<char>::E : int { echar };       // ill-formed, A<char>::E was instantiated
                                                    // when A<char> was instantiated
-template<> enum class A<char>::S : int { schar }; // OK
 ```
 The placement of explicit specialization declarations for function
-templates, class templates, member functions of class templates, static
-data members of class templates, member classes of class templates,
-member enumerations of class templates, member class templates of class
-templates, member function templates of class templates, member
 functions of member templates of class templates, member functions of
-member templates of non-template classes, member function templates of
-member classes of class templates, etc., and the placement of partial
-specialization declarations of class templates, member class templates
-of non-template classes, member class templates of class templates,
-etc., can affect whether a program is well-formed according to the
-relative positioning of the explicit specialization declarations and
-their points of instantiation in the translation unit as specified above
-and below. When writing a specialization, be careful about its location;
-or to make it compile will be such a trial as to kindle its
-self-immolation.
 A template explicit specialization is in the scope of the namespace in
 which the template was defined.
 ``` cpp
@@ -665,11 +695,13 @@ namespace N {
   template<> class Y<double>;                   // forward declare intent to
                                                 // specialize for double
 }
 template<> class N::Y<double> { /* ... */ };      // OK: specialization
-                                                // in same namespace
 ```
 A *simple-template-id* that names a class template explicit
 specialization that has been declared but not defined can be used
 exactly like the names of other incompletely-defined classes (
@@ -710,13 +742,14 @@ template<class T> inline T g(T) { /* ... */ }
 template<> inline void f<>(int) { /* ... */ }   // OK: inline
 template<> int g<>(int) { /* ... */ }           // OK: not inline
 ```
-An explicit specialization of a static data member of a template is a
-definition if the declaration includes an initializer; otherwise, it is
-a declaration. The definition of a static data member of a template that
 requires default initialization must use a *braced-init-list*:
 ``` cpp
 template<> X Q<int>::x;         // declaration
 template<> X Q<int>::x ();      // error: declares a function
@@ -799,12 +832,13 @@ template <> template <> template<class T>
 template <class Y> template <>
   void A<Y>::B<double>::mf2() { }       // ill-formed; B<double> is specialized but
                                         // its enclosing class template A is not
 ```
-A specialization of a member function template or member class template
-of a non-specialized class template is itself a template.
 An explicit specialization declaration shall not be a friend
 declaration.
 Default function arguments shall not be specified in a declaration or a

 [[temp.expl.spec]]), the class template specialization is implicitly
 instantiated when the specialization is referenced in a context that
 requires a completely-defined object type or when the completeness of
 the class type affects the semantics of the program. The implicit
 instantiation of a class template specialization causes the implicit
+instantiation of the declarations, but not of the definitions, default
+arguments, or *exception-specification*s of the class member functions,
+member classes, scoped member enumerations, static data members and
+member templates; and it causes the implicit instantiation of the
+definitions of unscoped member enumerations and member anonymous unions.
+However, for the purpose of determining whether an instantiated
+redeclaration of a member is valid according to  [[class.mem]], a
+declaration that corresponds to a definition in the template is
+considered to be a definition.
 ``` cpp
 template<class T, class U>
 struct Outer {
   template<class X, class Y> struct Inner;
 ```
 Nothing in this example requires `class` `Z<double>`, `Z<int>::g()`, or
 `Z<char>::f()` to be implicitly instantiated.
+Unless a variable template specialization has been explicitly
+instantiated or explicitly specialized, the variable template
+specialization is implicitly instantiated when the specialization is
+used. A default template argument for a variable template is implicitly
+instantiated when the variable template is referenced in a context that
+requires the value of the default argument.
 A class template specialization is implicitly instantiated if the class
 type is used in a context that requires a completely-defined object type
 or if the completeness of the class type might affect the semantics of
 the program. In particular, if the semantics of an expression depend on
 the member or base class lists of a class template specialization, the
 If a function template or a member function template specialization is
 used in a way that involves overload resolution, a declaration of the
 specialization is implicitly instantiated ([[temp.over]]).
 An implementation shall not implicitly instantiate a function template,
+a variable template, a member template, a non-virtual member function, a
+member class, or a static data member of a class template that does not
+require instantiation. It is unspecified whether or not an
+implementation implicitly instantiates a virtual member function of a
+class template if the virtual member function would not otherwise be
+instantiated. The use of a template specialization in a default argument
+shall not cause the template to be implicitly instantiated except that a
+class template may be instantiated where its complete type is needed to
+determine the correctness of the default argument. The use of a default
+argument in a function call causes specializations in the default
+argument to be implicitly instantiated.
+Implicitly instantiated class, function, and variable template
+specializations are placed in the namespace where the template is
+defined. Implicitly instantiated specializations for members of a class
+template are placed in the namespace where the enclosing class template
+is defined. Implicitly instantiated member templates are placed in the
+namespace where the enclosing class or class template is defined.
 ``` cpp
 namespace N {
   template<class T> class List {
   public:
 argument to be used, the dependent names are looked up, the semantics
 constraints are checked, and the instantiation of any template used in
 the default argument is done as if the default argument had been an
 initializer used in a function template specialization with the same
 scope, the same template parameters and the same access as that of the
+function template `f` used at that point, except that the scope in which
+a closure type is declared ([[expr.prim.lambda]]) – and therefore its
+associated namespaces – remain as determined from the context of the
+definition for the default argument. This analysis is called *default
+argument instantiation*. The instantiated default argument is then used
+as the argument of `f`.
 Each default argument is instantiated independently.
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
   f(a, b);          // default argument z = zdef(T()) instantiated
   f(a);             // ill-formed; ydef is not declared
 }
 ```
+The *exception-specification* of a function template specialization is
+not instantiated along with the function declaration; it is instantiated
+when needed ([[except.spec]]). If such an *exception-specification* is
+needed but has not yet been instantiated, the dependent names are looked
+up, the semantics constraints are checked, and the instantiation of any
+template used in the *exception-specification* is done as if it were
+being done as part of instantiating the declaration of the
+specialization at that point.
 [[temp.point]] defines the point of instantiation of a template
 specialization.
 There is an implementation-defined quantity that specifies the limit on
 the total depth of recursive instantiations, which could involve more
 };
 ```
 ### Explicit instantiation <a id="temp.explicit">[[temp.explicit]]</a>
+A class, function, variable, or member template specialization can be
+explicitly instantiated from its template. A member function, member
+class or static data member of a class template can be explicitly
+instantiated from the member definition associated with its class
+template. An explicit instantiation of a function template or member
+function of a class template shall not use the `inline` or `constexpr`
+specifiers.
 The syntax for explicit instantiation is:
 ``` bnf
 explicit-instantiation:
 a *qualified-id*, in which case the *unqualified-id* of the
 *qualified-id* must be a *template-id*. If the explicit instantiation is
 for a member function, a member class or a static data member of a class
 template specialization, the name of the class template specialization
 in the *qualified-id* for the member name shall be a
+*simple-template-id*. If the explicit instantiation is for a variable,
+the *unqualified-id* in the declaration shall be a *template-id*. An
+explicit instantiation shall appear in an enclosing namespace of its
+template. If the name declared in the explicit instantiation is an
+unqualified name, the explicit instantiation shall appear in the
+namespace where its template is declared or, if that namespace is
+inline ([[namespace.def]]), any namespace from its enclosing namespace
+set. Regarding qualified names in declarators, see  [[dcl.meaning]].
 ``` cpp
 template<class T> class Array { void mf(); };
 template class Array<char>;
 template void Array<int>::mf();
   template<class T> void f(T&) { }
 }
 template void N::f<int>(int&);
 ```
+A declaration of a function template, a variable template, a member
+function or static data member of a class template, or a member function
+template of a class or class template shall precede an explicit
+instantiation of that entity. A definition of a class template, a member
+class of a class template, or a member class template of a class or
+class template shall precede an explicit instantiation of that entity
+unless the explicit instantiation is preceded by an explicit
+specialization of the entity with the same template arguments. If the
+*declaration* of the explicit instantiation names an implicitly-declared
+special member function (Clause  [[special]]), the program is
+ill-formed.
 For a given set of template arguments, if an explicit instantiation of a
 template appears after a declaration of an explicit specialization for
 that template, the explicit instantiation has no effect. Otherwise, for
 an explicit instantiation definition the definition of a function
+template, a variable template, a member function template, or a member
+function or static data member of a class template shall be present in
+every translation unit in which it is explicitly instantiated.
+An explicit instantiation of a class, function template, or variable
+template specialization is placed in the namespace in which the template
+is defined. An explicit instantiation for a member of a class template
+is placed in the namespace where the enclosing class template is
+defined. An explicit instantiation for a member template is placed in
+the namespace where the enclosing class or class template is defined.
 ``` cpp
 namespace N {
   template<class T> class Y { void mf() { } };
 }
 ```
 An explicit instantiation that names a class template specialization is
 also an explicit instantiation of the same kind (declaration or
 definition) of each of its members (not including members inherited from
+base classes and members that are templates) that has not been
+previously explicitly specialized in the translation unit containing the
+explicit instantiation, except as described below. In addition, it will
+typically be an explicit instantiation of certain
+implementation-dependent data about the class.
 An explicit instantiation definition that names a class template
 specialization explicitly instantiates the class template specialization
 and is an explicit instantiation definition of only those members that
 have been defined at the point of instantiation.
+Except for inline functions, declarations with types deduced from their
+initializer or return value ([[dcl.spec.auto]]), `const` variables of
+literal types, variables of reference types, and class template
+specializations, explicit instantiation declarations have the effect of
+suppressing the implicit instantiation of the entity to which they
+refer. The intent is that an inline function that is the subject of an
+explicit instantiation declaration will still be implicitly instantiated
+when odr-used ([[basic.def.odr]]) so that the body can be considered
+for inlining, but that no out-of-line copy of the inline function would
+be generated in the translation unit.
 If an entity is the subject of both an explicit instantiation
 declaration and an explicit instantiation definition in the same
 translation unit, the definition shall follow the declaration. An entity
 that is the subject of an explicit instantiation declaration and that is
 An explicit specialization of any of the following:
 - function template
 - class template
+- variable template
 - member function of a class template
 - static data member of a class template
 - member class of a class template
 - member enumeration of a class template
 - member class template of a class or class template
 [[namespace.def]]), any namespace from its enclosing namespace set. Such
 a declaration may also be a definition. If the declaration is not a
 definition, the specialization may be defined later (
 [[namespace.memdef]]).
+A declaration of a function template, class template, or variable
+template being explicitly specialized shall precede the declaration of
+the explicit specialization. A declaration, but not a definition of the
+template is required. The definition of a class or class template shall
+precede the declaration of an explicit specialization for a member
+template of the class or class template.
 ``` cpp
 template<> class X<int> { /* ... */ };          // error: X not a template
 template<class T> class X;
 template<> class X<char*> { /* ... */ };        // OK: X is a template
 ```
 A member function, a member function template, a member class, a member
+enumeration, a member class template, a static data member, or a static
+data member template of a class template may be explicitly specialized
+for a class specialization that is implicitly instantiated; in this
+case, the definition of the class template shall precede the explicit
+specialization for the member of the class template. If such an explicit
+specialization for the member of a class template names an
+implicitly-declared special member function (Clause  [[special]]), the
+program is ill-formed.
 A member of an explicitly specialized class is not implicitly
 instantiated from the member declaration of the class template; instead,
 the member of the class template specialization shall itself be
 explicitly defined if its definition is required. In this case, the
 };
 template<> enum A<int>::E : int { eint };         // OK
 template<> enum class A<int>::S : int { sint };   // OK
 template<class T> enum A<T>::E : T { eT };
 template<class T> enum class A<T>::S : T { sT };
+template<> enum A<char>::E : char { echar };       // ill-formed, A<char>::E was instantiated
                                                    // when A<char> was instantiated
+template<> enum class A<char>::S : char { schar }; // OK
 ```
 The placement of explicit specialization declarations for function
+templates, class templates, variable templates, member functions of
+class templates, static data members of class templates, member classes
+of class templates, member enumerations of class templates, member class
+templates of class templates, member function templates of class
+templates, static data member templates of class templates, member
 functions of member templates of class templates, member functions of
+member templates of non-template classes, static data member templates
+of non-template classes, member function templates of member classes of
+class templates, etc., and the placement of partial specialization
+declarations of class templates, variable templates, member class
+templates of non-template classes, static data member templates of
+non-template classes, member class templates of class templates, etc.,
+can affect whether a program is well-formed according to the relative
+positioning of the explicit specialization declarations and their points
+of instantiation in the translation unit as specified above and below.
+When writing a specialization, be careful about its location; or to make
+it compile will be such a trial as to kindle its self-immolation.
 A template explicit specialization is in the scope of the namespace in
 which the template was defined.
 ``` cpp
   template<> class Y<double>;                   // forward declare intent to
                                                 // specialize for double
 }
 template<> class N::Y<double> { /* ... */ };      // OK: specialization
+                                                // in enclosing namespace
+template<> class N::Y<short> { /* ... */ };       // OK: specialization
+                                                // in enclosing namespace
 ```
 A *simple-template-id* that names a class template explicit
 specialization that has been declared but not defined can be used
 exactly like the names of other incompletely-defined classes (
 template<> inline void f<>(int) { /* ... */ }   // OK: inline
 template<> int g<>(int) { /* ... */ }           // OK: not inline
 ```
+An explicit specialization of a static data member of a template or an
+explicit specialization of a static data member template is a definition
+if the declaration includes an initializer; otherwise, it is a
+declaration. The definition of a static data member of a template that
 requires default initialization must use a *braced-init-list*:
 ``` cpp
 template<> X Q<int>::x;         // declaration
 template<> X Q<int>::x ();      // error: declares a function
 template <class Y> template <>
   void A<Y>::B<double>::mf2() { }       // ill-formed; B<double> is specialized but
                                         // its enclosing class template A is not
 ```
+A specialization of a member function template, member class template,
+or static data member template of a non-specialized class template is
+itself a template.
 An explicit specialization declaration shall not be a friend
 declaration.
 Default function arguments shall not be specified in a declaration or a

Diff to HTML by rtfpessoa