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

Files changed (1) hide show

tmp/tmpkwoxny13/{from.md → to.md} +48 -28

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

@@ -5,18 +5,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;
@@ -71,10 +72,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
@@ -134,28 +142,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:
@@ -182,13 +190,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()));
@@ -202,10 +213,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

 [[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

Diff to HTML by rtfpessoa