[temp.spec] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpbtgzrt0d/{from.md → to.md} +56 -87

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

@@ -25,13 +25,12 @@ variable template, a class template, a member of a class template, or a
 member template. An explicit specialization declaration is introduced by
 `template<>`. In an explicit specialization declaration for a variable
 template, a class template, a member of a class template, or a class
 member template, the variable or class that is explicitly specialized
 shall be specified with a *simple-template-id*. In the explicit
-specialization declaration for a function template or a member function
-template, the function or member function explicitly specialized may be
-specified using a *template-id*.
 [*Example 1*:
 ``` cpp
 template<class T = int> struct A {
@@ -364,13 +363,13 @@ void g(S<int>& sr) {
 };
 ```
 — *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 or static data member of a templated class, or a
 substatement of a constexpr if statement [[stmt.if]], unless such
@@ -425,18 +424,18 @@ void g(A a, A b, A c) {
 }
 ```
 — *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 6*:  [[temp.point]] defines the point of instantiation of a
 template specialization. — *end note*]
 There is an *implementation-defined* quantity that specifies the limit
@@ -555,11 +554,11 @@ instantiation is for a variable template specialization, the
 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&);
@@ -584,11 +583,11 @@ The *declaration* in an *explicit-instantiation* and the *declaration*
 produced by the corresponding substitution into the templated function,
 variable, or class are two declarations of the same entity.
 [*Note 1*:
-These declarations are required to have matching types as specified in
 [[basic.link]], except as specified in  [[except.spec]].
 [*Example 2*:
 ``` cpp
@@ -596,11 +595,11 @@ template<typename T> T var = {};
 template float var<float>;      // OK, instantiated variable has type float
 template int var<int[16]>[];    // OK, absence of major array bound is permitted
 template int *var<int>;         // error: instantiated variable has type int
 template<typename T> auto av = T();
-template int av<int>;           // OK, variable with type int can be redeclared with type auto
 template<typename T> auto f() {}
 template void f<int>();         // error: function with deduced return type
                                 // redeclared with non-deduced return type[dcl.spec.auto]
 ```
@@ -620,36 +619,18 @@ 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.
-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
-[[temp.deduct.decl]]. If all template arguments can be deduced, the
-empty template argument list `<>` may be omitted.
-[*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*]
-[*Note 2*: An explicit instantiation of a constrained template is
-required to satisfy that template’s associated constraints
-[[temp.constr.decl]]. The satisfaction of constraints is determined when
-forming the template name of an explicit instantiation in which all
-template arguments are specified [[temp.names]], or, for explicit
-instantiations of function templates, during template argument deduction
-[[temp.deduct.decl]] when one or more trailing template arguments are
-left unspecified. — *end note*]
 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 direct non-template members that has not been
 previously explicitly specialized in the translation unit containing the
@@ -689,11 +670,11 @@ An explicit instantiation declaration shall not name a specialization of
 a template with internal linkage.
 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.
@@ -725,24 +706,25 @@ explicit-specialization:
 [*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
-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.
 — *end example*]
 The *declaration* in an *explicit-specialization* shall not be an
 *export-declaration*. An explicit specialization shall not use a
@@ -756,11 +738,11 @@ An explicit specialization does not introduce a name
 [[basic.scope.scope]]. A declaration of a function template, class
 template, or variable template being explicitly specialized shall be
 reachable from 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 be reachable from the
 declaration of an explicit specialization for a member template of the
 class or class template.
@@ -906,13 +888,14 @@ 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 *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 5*:
 ``` cpp
@@ -923,47 +906,33 @@ X<int>* p;                                      // OK, pointer to declared class
 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 [[temp.deduct.decl]].
-[*Example 6*:
-``` 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*]
-[*Note 2*: An explicit specialization of a constrained template is
-required to satisfy that template’s associated constraints
-[[temp.constr.decl]]. The satisfaction of constraints is determined when
-forming the template name of an explicit specialization in which all
-template arguments are specified [[temp.names]], or, for explicit
-specializations of function templates, during template argument
-deduction [[temp.deduct.decl]] when one or more trailing template
-arguments are left unspecified. — *end note*]
 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]].
 Whether an explicit specialization of a function or variable template is
 inline, constexpr, constinit, or consteval is determined by the explicit
 specialization and is independent of those properties of the template.
-Similarly, attributes appearing in the declaration of a template have no
-effect on an explicit specialization of that template.
-[*Example 7*:
 ``` cpp
 template<class T> void f(T) { ... }
 template<class T> inline T g(T) { ... }
@@ -982,11 +951,11 @@ template<> void h<int>(int i) {
 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 3*:
 The definition of a static data member of a template for which
 default-initialization is desired can use functional cast notation
 [[expr.type.conv]]:
@@ -1002,11 +971,11 @@ 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 8*:
 ``` cpp
 template<class T> struct A {
   void f(T);
   template<class X1> void g1(T, X1);
@@ -1038,11 +1007,11 @@ 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.
-[*Example 9*:
 ``` cpp
 template<class T1> class A {
   template<class T2> class B {
     void mf();
@@ -1064,11 +1033,11 @@ 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 10*:
 ``` cpp
 template <class T1> class A {
   template<class T2> class B {
     template<class T3> void mf1(T3);
@@ -1100,10 +1069,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. \[*Note 4*: Default
   function arguments can be specified in the declaration or definition
   of a member function of a class template specialization that is
   explicitly specialized. — *end note*]

 member template. An explicit specialization declaration is introduced by
 `template<>`. In an explicit specialization declaration for a variable
 template, a class template, a member of a class template, or a class
 member template, the variable or class that is explicitly specialized
 shall be specified with a *simple-template-id*. In the explicit
+specialization declaration for a function template, the function
+explicitly specialized may be specified using a *template-id*.
 [*Example 1*:
 ``` cpp
 template<class T = int> struct A {
 };
 ```
 — *end example*]
+If a 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 static data member of a templated class, or a
 substatement of a constexpr if statement [[stmt.if]], unless such
 }
 ```
 — *end example*]
+The *noexcept-specifier* and *function-contract-specifier*s of a
+function template specialization are not instantiated along with the
+function declaration; they are instantiated when needed
+[[except.spec]], [[dcl.contract.func]]. If such a 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 specifier is done as if it were being done as part
+of instantiating the declaration of the specialization at that point.
 [*Note 6*:  [[temp.point]] defines the point of instantiation of a
 template specialization. — *end note*]
 There is an *implementation-defined* quantity that specifies the limit
 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[temp.arg.explicit]
 namespace N {
   template<class T> void f(T&) { }
 }
 template void N::f<int>(int&);
 produced by the corresponding substitution into the templated function,
 variable, or class are two declarations of the same entity.
 [*Note 1*:
+These declarations need to have matching types as specified in
 [[basic.link]], except as specified in  [[except.spec]].
 [*Example 2*:
 ``` cpp
 template float var<float>;      // OK, instantiated variable has type float
 template int var<int[16]>[];    // OK, absence of major array bound is permitted
 template int *var<int>;         // error: instantiated variable has type int
 template<typename T> auto av = T();
+template int av<int>;           // OK, variable with type auto can be redeclared with type int
 template<typename T> auto f() {}
 template void f<int>();         // error: function with deduced return type
                                 // redeclared with non-deduced return type[dcl.spec.auto]
 ```
 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.
+[*Note 2*: An explicit instantiation of a constrained template needs to
+satisfy that template’s associated constraints [[temp.constr.decl]]. The
+satisfaction of constraints is determined when forming the template name
+of an explicit instantiation in which all template arguments are
+specified [[temp.names]], or, for explicit instantiations of function
+templates, during template argument deduction [[temp.deduct.decl]] when
+one or more trailing template arguments are left
+unspecified. — *end note*]
 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 direct non-template members that has not been
 previously explicitly specialized in the translation unit containing the
 a template with internal linkage.
 An explicit instantiation does not constitute a use of a default
 argument, so default argument instantiation is not done.
+[*Example 3*:
 ``` 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.
 [*Example 1*:
 ``` cpp
 template<class T> class stream;
+template<> class stream<char> { ... };    // #1
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v) { ... }
+template<> void sort<int>(Array<int>&);         // #2
+template<> void sort(Array<char*>&);            // #3 template argument is deduced[temp.arg.explicit]
 ```
+Given these declarations, \#1 will be used as the definition of streams
+of `char`s; other streams will be handled by class template
+specializations instantiated from the class template. Similarly, \#2
+will be used as the sort function for arguments of type `Array<int>` and
+\#3 will be used for arguments of type `Array<char*>`; other `Array`
+types will be sorted by functions generated from the function template.
 — *end example*]
 The *declaration* in an *explicit-specialization* shall not be an
 *export-declaration*. An explicit specialization shall not use a
 [[basic.scope.scope]]. A declaration of a function template, class
 template, or variable template being explicitly specialized shall be
 reachable from the declaration of the explicit specialization.
 [*Note 1*: A declaration, but not a definition of the template is
+needed. — *end note*]
 The definition of a class or class template shall be reachable from the
 declaration of an explicit specialization for a member template of the
 class or class template.
 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.
+[*Note 2*:
+A class template explicit specialization that has been declared but not
+defined can be used exactly like other incompletely-defined classes
 [[basic.types]].
 [*Example 5*:
 ``` cpp
 X<int> x;                                       // error: object of incomplete class X<int>
 ```
 — *end example*]
+— *end note*]
+[*Note 3*: An explicit specialization of a constrained template needs
+to satisfy that template’s associated constraints [[temp.constr.decl]].
+The satisfaction of constraints is determined when forming the template
+name of an explicit specialization in which all template arguments are
+specified [[temp.names]], or, for explicit specializations of function
+templates, during template argument deduction [[temp.deduct.decl]] when
+one or more trailing template arguments are left
+unspecified. — *end note*]
 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]].
 Whether an explicit specialization of a function or variable template is
 inline, constexpr, constinit, or consteval is determined by the explicit
 specialization and is independent of those properties of the template.
+Similarly, attributes and *function-contract-specifier*s appearing in
+the declaration of a template have no effect on an explicit
+specialization of that template.
+[*Example 6*:
 ``` cpp
 template<class T> void f(T) { ... }
 template<class T> inline T g(T) { ... }
 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 4*:
 The definition of a static data member of a template for which
 default-initialization is desired can use functional cast notation
 [[expr.type.conv]]:
 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 7*:
 ``` cpp
 template<class T> struct A {
   void f(T);
   template<class X1> void g1(T, X1);
 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 8*:
 ``` cpp
 template<class T1> class A {
   template<class T2> class B {
     void mf();
 *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 9*:
 ``` cpp
 template <class T1> class A {
   template<class T2> class B {
     template<class T3> void mf1(T3);
 - 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 5*: Default
   function arguments can 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