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

Files changed (1) hide show

tmp/tmp1worqr21/{from.md → to.md} +76 -49

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

@@ -22,39 +22,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
@@ -78,92 +88,109 @@ 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.
 ```

 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*]

Diff to HTML by rtfpessoa