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

Files changed (1) hide show

tmp/tmpqh5rxty2/{from.md → to.md} +326 -186

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

@@ -23,10 +23,12 @@ class template or a class member template, the name of the class that is
 explicitly specialized shall be a *simple-template-id*. In the explicit
 specialization declaration for a function template or a member function
 template, the name of the function or member function explicitly
 specialized may be a *template-id*.
 ``` cpp
 template<class T = int> struct A {
   static int x;
 };
 template<class U> void g(U) { }
@@ -42,10 +44,12 @@ template<class T = int> struct B {
   static int x;
 };
 template<> int B<>::x = 1;              // specialize for T == int
 ```
 An instantiated template specialization can be either implicitly
 instantiated ([[temp.inst]]) for a given argument list or be explicitly
 instantiated ([[temp.explicit]]). A specialization is a class,
 function, or class member that is either instantiated or explicitly
 specialized ([[temp.expl.spec]]).
@@ -63,10 +67,12 @@ For a given template and a given set of *template-argument*s,
 An implementation is not required to diagnose a violation of this rule.
 Each class template specialization instantiated from a template has its
 own copy of any static members.
 ``` cpp
 template<class T> class X {
   static T s;
 };
 template<class T> T X<T>::s = 0;
@@ -77,28 +83,98 @@ X<char*> bb;
 `X<int>`
 has a static member `s` of type `int` and `X<char*>` has a static member
 `s` of type `char*`.
 ### Implicit instantiation <a id="temp.inst">[[temp.inst]]</a>
 Unless a class template specialization has been explicitly
 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, 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;
@@ -114,28 +190,43 @@ Outer<int, int> outer;                          // error at #2
 defined but noted as being associated with a definition in
 `Outer<T, U>`.) \#2 is also a redeclaration of \#1a. It is noted as
 associated with a definition, so it is an invalid redeclaration of the
 same partial specialization.
 Unless a member of a class template or a member template has been
 explicitly instantiated or explicitly specialized, the specialization of
 the member is implicitly instantiated when the specialization is
 referenced in a context that requires the member definition to exist; in
-particular, the initialization (and any associated side-effects) of a
 static data member does not occur unless the static data member is
 itself used in a way that requires the definition of the static data
 member to exist.
 Unless a function template specialization has been explicitly
 instantiated or explicitly specialized, the function template
 specialization is implicitly instantiated when the specialization is
-referenced in a context that requires a function definition to exist.
-Unless a call is to a function template explicit specialization or to a
-member function of an explicitly specialized class template, a default
-argument for a function template or a member function of a class
-template is implicitly instantiated when the function is called in a
-context that requires the value of the default argument.
 ``` cpp
 template<class T> struct Z {
   void f();
   void g();
@@ -153,47 +244,25 @@ void h() {
 ```
 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
-class template specialization is implicitly generated. For instance,
-deleting a pointer to class type depends on whether or not the class
-declares a destructor, and conversion between pointer to class types
-depends on the inheritance relationship between the two classes
-involved.
-``` cpp
-template<class T> class B { /* ... */ };
-template<class T> class D : public B<T> { /* ... */ };
-void f(void*);
-void f(B<int>*);
-void g(D<int>* p, D<char>* pp, D<double>* ppp) {
-  f(p);             // instantiation of D<int> required: call f(B<int>*)
-  B<char>* q = pp;  // instantiation of D<char> required:
-                    // convert D<char>* to B<char>*
-  delete ppp;       // instantiation of D<double> required
-}
-```
-If the overload resolution process can determine the correct function to
-call without instantiating a class template definition, it is
 unspecified whether that instantiation actually takes place.
 ``` cpp
 template <class T> struct S {
   operator int();
 };
@@ -205,31 +274,21 @@ void g(S<int>& sr) {
   f(sr);            // instantiation of S<int> allowed but not required
                     // instantiation of S<float> allowed but not required
 };
 ```
-If an implicit instantiation of a class template specialization is
-required and the template is declared but not defined, the program is
-ill-formed.
-``` cpp
-template<class T> class X;
-X<char> ch;         // error: definition of X required
-```
-The implicit instantiation of a class template does not cause any static
-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 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
@@ -242,10 +301,12 @@ 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:
     T* get();
@@ -265,25 +326,29 @@ void g(Map<const char*,int>& m) {
 a call of `lt.get()` from `Map<const char*,int>::get()` would place
 `List<int>::get()` in the namespace `N` rather than in the global
 namespace.
 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, 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()));
 class  A { };
@@ -294,36 +359,42 @@ 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
 }
 ```
-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
-than one template. The result of an infinite recursion in instantiation
-is undefined.
 ``` cpp
 template<class T> class X {
   X<T>* p;          // OK
   X<T*> a;          // implicit generation of X<T> requires
                     // the implicit instantiation of X<T*> which requires
-                    // the implicit instantiation of X<T**> which ...
 };
 ```
 ### 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
@@ -346,39 +417,49 @@ instantiation declaration begins with the `extern` keyword.
 If the explicit instantiation is for a class or member class, the
 *elaborated-type-specifier* in the *declaration* shall include a
 *simple-template-id*. If the explicit instantiation is for a function or
 member function, the *unqualified-id* in the *declaration* shall be
 either a *template-id* or, where all template arguments can be deduced,
-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*. 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 sort(Array<T>& v) { /* ... */ }
 template void sort(Array<char>&);       // argument is deduced here
 namespace N {
   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
@@ -402,97 +483,114 @@ 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() { } };
 }
-template class Y<int>; // error: class template Y not visible
-                                        // in the global namespace
 using N::Y;
-template class Y<int>; // error: explicit instantiation outside of the
-                                        // namespace of the template
 template class N::Y<char*>;             // OK: explicit instantiation in namespace N
-template void N::Y<double>::mf();       // OK: explicit instantiation
-                                        // in namespace N
 ```
 A trailing *template-argument* can be left unspecified in an explicit
 instantiation of a function template specialization or of a member
 function template specialization provided it can be deduced from the
 type of a function parameter ([[temp.deduct]]).
 ``` cpp
-template<class T> class Array { /* ... */ };
-template<class T> void sort(Array<T>& v) { /* ... */ }
-// instantiate sort(Array<int>&) - template-argument deduced
 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 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
 also used in a way that would otherwise cause an implicit
 instantiation ([[temp.inst]]) in the translation unit shall be the
 subject of an explicit instantiation definition somewhere in the
 program; otherwise the program is ill-formed, no diagnostic required.
-This rule does apply to inline functions even though an explicit
-instantiation declaration of such an entity has no other normative
-effect. This is needed to ensure that if the address of an inline
-function is taken in a translation unit in which the implementation
-chose to suppress the out-of-line body, another translation unit will
-supply the body. An explicit instantiation declaration shall not name a
-specialization of a template with internal linkage.
 The usual access checking rules do not apply to names used to specify
-explicit instantiations. In particular, the template arguments and names
-used in the function declarator (including parameter types, return types
-and exception specifications) may be private types or objects which
-would normally not be accessible and the template may be a member
-template or member function which would not normally be accessible.
 An explicit instantiation does not constitute a use of a default
 argument, so default argument instantiation is not done.
 ``` cpp
 char* p = 0;
 template<class T> T g(T x = &p) { return x; }
 template int g<int>(int);       // OK even though &p isn't an int.
 ```
 ### Explicit specialization <a id="temp.expl.spec">[[temp.expl.spec]]</a>
 An explicit specialization of any of the following:
 - function template
@@ -510,17 +608,19 @@ can be declared by a declaration introduced by `template<>`; that is:
 ``` bnf
 explicit-specialization:
   'template < >' declaration
 ```
 ``` cpp
 template<class T> class stream;
-template<> class stream<char> { /* ... */ };
-template<class T> class Array { /* ... */ };
-template<class T> void sort(Array<T>& v) { /* ... */ }
 template<> void sort<char*>(Array<char*>&);
 ```
 Given these declarations, `stream<char>` will be used as the definition
@@ -528,34 +628,39 @@ of streams of `char`s; other streams will be handled by class template
 specializations instantiated from the class template. Similarly,
 `sort<char*>` will be used as the sort function for arguments of type
 `Array<char*>`; other `Array` types will be sorted by functions
 generated from the template.
-An explicit specialization shall be declared in a namespace enclosing
-the specialized template. An explicit specialization whose
-*declarator-id* is not qualified shall be declared in the nearest
-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, 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
@@ -578,10 +683,12 @@ manner as members of normal classes, and not using the `template<>`
 syntax. The same is true when defining a member of an explicitly
 specialized member class. However, `template<>` is used in defining a
 member of an explicitly specialized member class template that is
 specialized as a class template.
 ``` cpp
 template<class T> struct A {
   struct B { };
   template<class U> struct C { };
 };
@@ -593,40 +700,40 @@ template<> struct A<int> {
 void h() {
   A<int> a;
   a.f(16);          // A<int>::f must be defined somewhere
 }
-// template<> not used for a member of an
-// explicitly specialized class template
-void A<int>::f(int) { /* ... */ }
 template<> struct A<char>::B {
   void f();
 };
-// template<> also not used when defining a member of
-// an explicitly specialized member class
-void A<char>::B::f() { /* ... */ }
 template<> template<class U> struct A<char>::C {
   void f();
 };
-// template<> is used when defining a member of an explicitly
-// specialized member class template specialized as a class template
 template<>
-template<class U> void A<char>::C<U>::f() { /* ... */ }
 template<> struct A<short>::B {
   void f();
 };
-template<> void A<short>::B::f() { /* ... */ } // error: template<> not permitted
 template<> template<class U> struct A<short>::C {
   void f();
 };
-template<class U> void A<short>::C<U>::f() { /* ... */ } // error: template<> required
 ```
 If a template, a member template or a member of a class template is
 explicitly specialized then that specialization shall be declared before
 the first use of that specialization that would cause an implicit
 instantiation to take place, in every translation unit in which such a
 use occurs; no diagnostic is required. If the program does not provide a
@@ -635,22 +742,22 @@ is used in a way that would cause an implicit instantiation to take
 place or the member is a virtual member function, the program is
 ill-formed, no diagnostic required. An implicit instantiation is never
 generated for an explicit specialization that is declared but not
 defined.
 ``` cpp
 class String { };
-template<class T> class Array { /* ... */ };
-template<class T> void sort(Array<T>& v) { /* ... */ }
 void f(Array<String>& v) {
-  sort(v);          // use primary template
-                    // sort(Array<T>&), T is String
 }
-template<> void sort<String>(Array<String>& v); // error: specialization
-                                                // after use of primary template
 template<> void sort<>(Array<char*>& v);            // OK: sort<char*> not yet used
 template<class T> struct A {
   enum E : T;
   enum class S : T;
 };
@@ -661,10 +768,12 @@ 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
@@ -683,87 +792,108 @@ 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
 namespace N {
-  template<class T> class X { /* ... */ };
-  template<class T> class Y { /* ... */ };
-  template<> class X<int> { /* ... */ }; // OK: specialization
- // in same namespace
-  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 (
 [[basic.types]]).
 ``` cpp
 template<class T> class X;                      // X is a class template
 template<> class X<int>;
 X<int>* p;                                      // OK: pointer to declared class X<int>
 X<int> x;                                       // error: object of incomplete class X<int>
 ```
 A trailing *template-argument* can be left unspecified in the
 *template-id* naming an explicit function template specialization
 provided it can be deduced from the function argument type.
 ``` cpp
-template<class T> class Array { /* ... */ };
 template<class T> void sort(Array<T>& v);
 // explicit specialization for sort(Array<int>&)
 // with deduced template-argument of type int
 template<> void sort(Array<int>&);
 ```
 A function with the same name as a template and a type that exactly
 matches that of a template specialization is not an explicit
 specialization ([[temp.fct]]).
-An explicit specialization of a function template is inline only if it
-is declared with the `inline` specifier or defined as deleted, and
-independently of whether its function template is inline.
 ``` cpp
-template<class T> void f(T) { /* ... */ }
-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 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<> X Q<int>::x { };                     // definition
 ```
 A member or a member template of a class template may be explicitly
 specialized for a given implicit instantiation of the class template,
 even if the member or member template is defined in the class template
 definition. An explicit specialization of a member or member template is
 specified using the syntax for explicit specialization.
 ``` cpp
 template<class T> struct A {
   void f(T);
   template<class X1> void g1(T, X1);
   template<class X2> void g2(T, X2);
@@ -787,37 +917,45 @@ template<> template<>
 // member specialization even if defined in class definition
 template<> void A<int>::h(int) { }
 ```
 A member or a member template may be nested within many enclosing class
 templates. In an explicit specialization for such a member, the member
 declaration shall be preceded by a `template<>` for each enclosing class
 template that is explicitly specialized.
 ``` cpp
 template<class T1> class A {
   template<class T2> class B {
     void mf();
   };
 };
 template<> template<> class A<int>::B<double>;
 template<> template<> void A<char>::B<char>::mf();
 ```
 In an explicit specialization declaration for a member of a class
 template or a member template that appears in namespace scope, the
 member template and some of its enclosing class templates may remain
 unspecialized, except that the declaration shall not explicitly
 specialize a class member template if its enclosing class templates are
 not explicitly specialized as well. In such explicit specialization
 declaration, the keyword `template` followed by a
 *template-parameter-list* shall be provided instead of the `template<>`
 preceding the explicit specialization declaration of the member. The
-types of the *template-parameters* in the *template-parameter-list*
 shall be the same as those specified in the primary template definition.
 ``` cpp
 template <class T1> class A {
   template<class T2> class B {
     template<class T3> void mf1(T3);
     void mf2();
@@ -832,10 +970,12 @@ 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, 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
@@ -846,10 +986,10 @@ definition for one of the following explicit specializations:
 - the explicit specialization of a function template;
 - the explicit specialization of a member function template;
 - the explicit specialization of a member function of a class template
   where the class template specialization to which the member function
-  specialization belongs is implicitly instantiated. Default function
-  arguments may be specified in the declaration or definition of a
-  member function of a class template specialization that is explicitly
-  specialized.

 explicitly specialized shall be a *simple-template-id*. In the explicit
 specialization declaration for a function template or a member function
 template, the name of the function or member function explicitly
 specialized may be a *template-id*.
+[*Example 1*:
 ``` cpp
 template<class T = int> struct A {
   static int x;
 };
 template<class U> void g(U) { }
   static int x;
 };
 template<> int B<>::x = 1;              // specialize for T == int
 ```
+— *end example*]
 An instantiated template specialization can be either implicitly
 instantiated ([[temp.inst]]) for a given argument list or be explicitly
 instantiated ([[temp.explicit]]). A specialization is a class,
 function, or class member that is either instantiated or explicitly
 specialized ([[temp.expl.spec]]).
 An implementation is not required to diagnose a violation of this rule.
 Each class template specialization instantiated from a template has its
 own copy of any static members.
+[*Example 2*:
 ``` cpp
 template<class T> class X {
   static T s;
 };
 template<class T> T X<T>::s = 0;
 `X<int>`
 has a static member `s` of type `int` and `X<char*>` has a static member
 `s` of type `char*`.
+— *end example*]
+If a function declaration acquired its function type through a dependent
+type ([[temp.dep.type]]) without using the syntactic form of a function
+declarator, the program is ill-formed.
+[*Example 3*:
+``` cpp
+template<class T> struct A {
+  static T t;
+};
+typedef int function();
+A<function> a;      // ill-formed: would declare A<function>::t as a static member function
+```
+— *end example*]
 ### Implicit instantiation <a id="temp.inst">[[temp.inst]]</a>
 Unless a class template specialization has been explicitly
 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.
+[*Note 1*: In particular, if the semantics of an expression depend on
+the member or base class lists of a class template specialization, the
+class template specialization is implicitly generated. For instance,
+deleting a pointer to class type depends on whether or not the class
+declares a destructor, and a conversion between pointers to class type
+depends on the inheritance relationship between the two classes
+involved. — *end note*]
+[*Example 1*:
+``` cpp
+template<class T> class B { ... };
+template<class T> class D : public B<T> { ... };
+void f(void*);
+void f(B<int>*);
+void g(D<int>* p, D<char>* pp, D<double>* ppp) {
+  f(p);             // instantiation of D<int> required: call f(B<int>*)
+  B<char>* q = pp;  // instantiation of D<char> required: convert D<char>* to B<char>*
+  delete ppp;       // instantiation of D<double> required
+}
+```
+— *end example*]
+If a class template has been declared, but not defined, at the point of
+instantiation ([[temp.point]]), the instantiation yields an incomplete
+class type ([[basic.types]]).
+[*Example 2*:
+``` cpp
+template<class T> class X;
+X<char> ch;         // error: incomplete type X<char>
+```
+— *end example*]
+[*Note 2*: Within a template declaration, a local class (
+[[class.local]]) or enumeration and the members of a local class are
+never considered to be entities that can be separately instantiated
+(this includes their default arguments, *noexcept-specifier*s, and
+non-static data member initializers, if any). As a result, the dependent
+names are looked up, the semantic constraints are checked, and any
+templates used are instantiated as part of the instantiation of the
+entity within which the local class or enumeration is
+declared. — *end note*]
+The implicit instantiation of a class template specialization causes the
+implicit instantiation of the declarations, but not of the definitions,
+default arguments, or *noexcept-specifier*s of the class member
+functions, member classes, scoped member enumerations, static data
+members, member templates, and friends; 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 is valid according to  [[basic.def.odr]]
+and [[class.mem]], a declaration that corresponds to a definition in the
+template is considered to be a definition.
+[*Example 3*:
 ``` cpp
 template<class T, class U>
 struct Outer {
   template<class X, class Y> struct Inner;
 defined but noted as being associated with a definition in
 `Outer<T, U>`.) \#2 is also a redeclaration of \#1a. It is noted as
 associated with a definition, so it is an invalid redeclaration of the
 same partial specialization.
+``` cpp
+template<typename T> struct Friendly {
+  template<typename U> friend int f(U) { return sizeof(T); }
+};
+Friendly<char> fc;
+Friendly<float> ff;                             // ill-formed: produces second definition of f(U)
+```
+— *end example*]
 Unless a member of a class template or a member template has been
 explicitly instantiated or explicitly specialized, the specialization of
 the member is implicitly instantiated when the specialization is
 referenced in a context that requires the member definition to exist; in
+particular, the initialization (and any associated side effects) of a
 static data member does not occur unless the static data member is
 itself used in a way that requires the definition of the static data
 member to exist.
 Unless a function template specialization has been explicitly
 instantiated or explicitly specialized, the function template
 specialization is implicitly instantiated when the specialization is
+referenced in a context that requires a function definition to exist. A
+function whose declaration was instantiated from a friend function
+definition is implicitly instantiated when it is referenced in a context
+that requires a function definition to exist. Unless a call is to a
+function template explicit specialization or to a member function of an
+explicitly specialized class template, a default argument for a function
+template or a member function of a class template is implicitly
+instantiated when the function is called in a context that requires the
+value of the default argument.
+[*Example 4*:
 ``` cpp
 template<class T> struct Z {
   void f();
   void g();
 ```
 Nothing in this example requires `class` `Z<double>`, `Z<int>::g()`, or
 `Z<char>::f()` to be implicitly instantiated.
+— *end example*]
 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.
+If the function selected by overload resolution ([[over.match]]) can be
+determined without instantiating a class template definition, it is
 unspecified whether that instantiation actually takes place.
+[*Example 5*:
 ``` cpp
 template <class T> struct S {
   operator int();
 };
   f(sr);            // instantiation of S<int> allowed but not required
                     // instantiation of S<float> allowed but not required
 };
 ```
+— *end example*]
 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, a static data member of a class template, or a
+substatement of a constexpr if statement ([[stmt.if]]), unless such
+instantiation is required. 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
 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.
+[*Example 6*:
 ``` cpp
 namespace N {
   template<class T> class List {
   public:
     T* get();
 a call of `lt.get()` from `Map<const char*,int>::get()` would place
 `List<int>::get()` in the namespace `N` rather than in the global
 namespace.
+— *end example*]
 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, except that the scope in which
+a closure type is declared ([[expr.prim.lambda.closure]]) – 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.
+[*Example 7*:
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
 class  A { };
   f(a, b);          // default argument z = zdef(T()) instantiated
   f(a);             // ill-formed; ydef is not declared
 }
 ```
+— *end example*]
+The *noexcept-specifier* of a function template specialization is not
+instantiated along with the function declaration; it is instantiated
+when needed ([[except.spec]]). If such an *noexcept-specifier* 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 *noexcept-specifier* is done as if it were being
+done as part of instantiating the declaration of the specialization at
+that point.
+[*Note 3*:  [[temp.point]] defines the point of instantiation of a
+template specialization. — *end note*]
+There is an *implementation-defined* quantity that specifies the limit
+on the total depth of recursive instantiations ([[implimits]]), which
+could involve more than one template. The result of an infinite
+recursion in instantiation is undefined.
+[*Example 8*:
 ``` cpp
 template<class T> class X {
   X<T>* p;          // OK
   X<T*> a;          // implicit generation of X<T> requires
                     // the implicit instantiation of X<T*> which requires
+                    // the implicit instantiation of X<T**> which …
 };
 ```
+— *end example*]
 ### 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
 If the explicit instantiation is for a class or member class, the
 *elaborated-type-specifier* in the *declaration* shall include a
 *simple-template-id*. If the explicit instantiation is for a function or
 member function, the *unqualified-id* in the *declaration* shall be
 either a *template-id* or, where all template arguments can be deduced,
+a *template-name* or *operator-function-id*.
+[*Note 1*: The declaration may declare a *qualified-id*, in which case
+the *unqualified-id* of the *qualified-id* must be a
+*template-id*. — *end note*]
+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.
+[*Note 2*: Regarding qualified names in declarators, see
+[[dcl.meaning]]. — *end note*]
+[*Example 1*:
 ``` cpp
 template<class T> class Array { void mf(); };
 template class Array<char>;
 template void Array<int>::mf();
+template<class T> void sort(Array<T>& v) { ... }
 template void sort(Array<char>&);       // argument is deduced here
 namespace N {
   template<class T> void f(T&) { }
 }
 template void N::f<int>(int&);
 ```
+— *end example*]
 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
 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.
+[*Example 2*:
 ``` cpp
 namespace N {
   template<class T> class Y { void mf() { } };
 }
+template class Y<int>; // error: class template Y not visible in the global namespace
 using N::Y;
+template class Y<int>; // error: explicit instantiation outside of the namespace of the template
 template class N::Y<char*>;             // OK: explicit instantiation in namespace N
+template void N::Y<double>::mf();       // OK: explicit instantiation in namespace N
 ```
+— *end example*]
 A trailing *template-argument* can be left unspecified in an explicit
 instantiation of a function template specialization or of a member
 function template specialization provided it can be deduced from the
 type of a function parameter ([[temp.deduct]]).
+[*Example 3*:
 ``` cpp
+template<class T> class Array { ... };
+template<class T> void sort(Array<T>& v) { ... }
+// instantiate sort(Array<int>&) -- template-argument deduced
 template void sort<>(Array<int>&);
 ```
+— *end example*]
 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.
+[*Note 3*: In addition, it will typically be an explicit instantiation
+of certain implementation-dependent data about the class. — *end note*]
 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 variables, 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.
+[*Note 4*: 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. — *end note*]
 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
 also used in a way that would otherwise cause an implicit
 instantiation ([[temp.inst]]) in the translation unit shall be the
 subject of an explicit instantiation definition somewhere in the
 program; otherwise the program is ill-formed, no diagnostic required.
+[*Note 5*: This rule does apply to inline functions even though an
+explicit instantiation declaration of such an entity has no other
+normative effect. This is needed to ensure that if the address of an
+inline function is taken in a translation unit in which the
+implementation chose to suppress the out-of-line body, another
+translation unit will supply the body. — *end note*]
+An explicit instantiation declaration shall not name a specialization of
+a template with internal linkage.
 The usual access checking rules do not apply to names used to specify
+explicit instantiations.
+[*Note 6*: In particular, the template arguments and names used in the
+function declarator (including parameter types, return types and
+exception specifications) may be private types or objects which would
+normally not be accessible and the template may be a member template or
+member function which would not normally be accessible. — *end note*]
 An explicit instantiation does not constitute a use of a default
 argument, so default argument instantiation is not done.
+[*Example 4*:
 ``` cpp
 char* p = 0;
 template<class T> T g(T x = &p) { return x; }
 template int g<int>(int);       // OK even though &p isn't an int.
 ```
+— *end example*]
 ### Explicit specialization <a id="temp.expl.spec">[[temp.expl.spec]]</a>
 An explicit specialization of any of the following:
 - function template
 ``` bnf
 explicit-specialization:
   'template < >' declaration
 ```
+[*Example 1*:
 ``` cpp
 template<class T> class stream;
+template<> class stream<char> { ... };
+template<class T> class Array { ... };
+template<class T> void sort(Array<T>& v) { ... }
 template<> void sort<char*>(Array<char*>&);
 ```
 Given these declarations, `stream<char>` will be used as the definition
 specializations instantiated from the class template. Similarly,
 `sort<char*>` will be used as the sort function for arguments of type
 `Array<char*>`; other `Array` types will be sorted by functions
 generated from the template.
+— *end example*]
+An explicit specialization may be declared in any scope in which the
+corresponding primary template may be defined ([[namespace.memdef]],
+[[class.mem]], [[temp.mem]]).
 A declaration of a function template, class template, or variable
 template being explicitly specialized shall precede the declaration of
+the explicit specialization.
+[*Note 1*: A declaration, but not a definition of the template is
+required. — *end note*]
+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.
+[*Example 2*:
 ``` cpp
+template<> class X<int> { ... };          // error: X not a template
 template<class T> class X;
+template<> class X<char*> { ... };        // OK: X is a template
 ```
+— *end example*]
 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
 syntax. The same is true when defining a member of an explicitly
 specialized member class. However, `template<>` is used in defining a
 member of an explicitly specialized member class template that is
 specialized as a class template.
+[*Example 3*:
 ``` cpp
 template<class T> struct A {
   struct B { };
   template<class U> struct C { };
 };
 void h() {
   A<int> a;
   a.f(16);          // A<int>::f must be defined somewhere
 }
+// template<> not used for a member of an explicitly specialized class template
+void A<int>::f(int) { ... }
 template<> struct A<char>::B {
   void f();
 };
+// template<> also not used when defining a member of an explicitly specialized member class
+void A<char>::B::f() { ... }
 template<> template<class U> struct A<char>::C {
   void f();
 };
+// template<> is used when defining a member of an explicitly specialized member class template
+// specialized as a class template
 template<>
+template<class U> void A<char>::C<U>::f() { ... }
 template<> struct A<short>::B {
   void f();
 };
+template<> void A<short>::B::f() { ... } // error: template<> not permitted
 template<> template<class U> struct A<short>::C {
   void f();
 };
+template<class U> void A<short>::C<U>::f() { ... } // error: template<> required
 ```
+— *end example*]
 If a template, a member template or a member of a class template is
 explicitly specialized then that specialization shall be declared before
 the first use of that specialization that would cause an implicit
 instantiation to take place, in every translation unit in which such a
 use occurs; no diagnostic is required. If the program does not provide a
 place or the member is a virtual member function, the program is
 ill-formed, no diagnostic required. An implicit instantiation is never
 generated for an explicit specialization that is declared but not
 defined.
+[*Example 4*:
 ``` cpp
 class String { };
+template<class T> class Array { ... };
+template<class T> void sort(Array<T>& v) { ... }
 void f(Array<String>& v) {
+  sort(v);          // use primary template sort(Array<T>&), T is String
 }
+template<> void sort<String>(Array<String>& v); // error: specialization after use of primary template
 template<> void sort<>(Array<char*>& v);            // OK: sort<char*> not yet used
 template<class T> struct A {
   enum E : T;
   enum class S : T;
 };
 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
 ```
+— *end example*]
 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
 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.
+[*Example 5*:
 ``` cpp
 namespace N {
+  template<class T> class X { ... };
+  template<class T> class Y { ... };
+  template<> class X<int> { ... }; // OK: specialization in same namespace
+  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
 ```
+— *end example*]
 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 (
 [[basic.types]]).
+[*Example 6*:
 ``` cpp
 template<class T> class X;                      // X is a class template
 template<> class X<int>;
 X<int>* p;                                      // OK: pointer to declared class X<int>
 X<int> x;                                       // error: object of incomplete class X<int>
 ```
+— *end example*]
 A trailing *template-argument* can be left unspecified in the
 *template-id* naming an explicit function template specialization
 provided it can be deduced from the function argument type.
+[*Example 7*:
 ``` cpp
+template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v);
 // explicit specialization for sort(Array<int>&)
 // with deduced template-argument of type int
 template<> void sort(Array<int>&);
 ```
+— *end example*]
 A function with the same name as a template and a type that exactly
 matches that of a template specialization is not an explicit
 specialization ([[temp.fct]]).
+An explicit specialization of a function or variable template is inline
+only if it is declared with the `inline` specifier or defined as
+deleted, and independently of whether its function or variable template
+is inline.
+[*Example 8*:
 ``` cpp
+template<class T> void f(T) { ... }
+template<class T> inline T g(T) { ... }
+template<> inline void f<>(int) { ... }   // OK: inline
+template<> int g<>(int) { ... }           // OK: not inline
 ```
+— *end example*]
 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.
+[*Note 2*:
+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<> X Q<int>::x { };                     // definition
 ```
+— *end note*]
 A member or a member template of a class template may be explicitly
 specialized for a given implicit instantiation of the class template,
 even if the member or member template is defined in the class template
 definition. An explicit specialization of a member or member template is
 specified using the syntax for explicit specialization.
+[*Example 9*:
 ``` cpp
 template<class T> struct A {
   void f(T);
   template<class X1> void g1(T, X1);
   template<class X2> void g2(T, X2);
 // member specialization even if defined in class definition
 template<> void A<int>::h(int) { }
 ```
+— *end example*]
 A member or a member template may be nested within many enclosing class
 templates. In an explicit specialization for such a member, the member
 declaration shall be preceded by a `template<>` for each enclosing class
 template that is explicitly specialized.
+[*Example 10*:
 ``` cpp
 template<class T1> class A {
   template<class T2> class B {
     void mf();
   };
 };
 template<> template<> class A<int>::B<double>;
 template<> template<> void A<char>::B<char>::mf();
 ```
+— *end example*]
 In an explicit specialization declaration for a member of a class
 template or a member template that appears in namespace scope, the
 member template and some of its enclosing class templates may remain
 unspecialized, except that the declaration shall not explicitly
 specialize a class member template if its enclosing class templates are
 not explicitly specialized as well. In such explicit specialization
 declaration, the keyword `template` followed by a
 *template-parameter-list* shall be provided instead of the `template<>`
 preceding the explicit specialization declaration of the member. The
+types of the *template-parameter*s in the *template-parameter-list*
 shall be the same as those specified in the primary template definition.
+[*Example 11*:
 ``` cpp
 template <class T1> class A {
   template<class T2> class B {
     template<class T3> void mf1(T3);
     void mf2();
 template <class Y> template <>
   void A<Y>::B<double>::mf2() { }       // ill-formed; B<double> is specialized but
                                         // its enclosing class template A is not
 ```
+— *end example*]
 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
 - the explicit specialization of a function template;
 - the explicit specialization of a member function template;
 - the explicit specialization of a member function of a class template
   where the class template specialization to which the member function
+  specialization belongs is implicitly instantiated. \[*Note 3*: Default
+ function arguments may be specified in the declaration or definition
+ of a member function of a class template specialization that is
+ explicitly specialized. — *end note*]

Diff to HTML by rtfpessoa