[temp.class] - C++20 → C++23

Files changed (1) hide show

tmp/tmpl2ya5yh0/{from.md → to.md} +35 -31

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

@@ -1,16 +1,19 @@
 ### Class templates <a id="temp.class">[[temp.class]]</a>
 A *class template* defines the layout and operations for an unbounded
 set of related types.
 [*Example 1*:
-A single class template `List` might provide an unbounded set of class
-definitions: one class `List<T>` for every type `T`, each describing a
-linked list of elements of type `T`. Similarly, a class template `Array`
-describing a contiguous, dynamic array might be defined like this:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
@@ -20,26 +23,25 @@ public:
   T& elem(int i) { return v[i]; }
 };
 ```
 The prefix `template<class T>` specifies that a template is being
-declared and that a *type-name* `T` may be used in the declaration. In
 other words, `Array` is a parameterized type with `T` as its parameter.
 — *end example*]
-When a member function, a member class, a member enumeration, a static
-data member or a member template of a class template is defined outside
-of the class template definition, the member definition is defined as a
-template definition in which the *template-head* is equivalent to that
-of the class template [[temp.over.link]]. The names of the template
-parameters used in the definition of the member may be different from
-the template parameter names used in the class template definition. The
-template argument list following the class template name in the member
-definition shall name the parameters in the same order as the one used
-in the template parameter list of the member. Each template parameter
-pack shall be expanded with an ellipsis in the template argument list.
 [*Example 2*:
 ``` cpp
 template<class T1, class T2> struct A {
@@ -70,11 +72,11 @@ template<C T> struct S {
   void g();
   void h();
   template<D U> struct Inner;
 };
-template<C A> void S<A>::f() { }        // OK: template-head{s} match
 template<typename T> void S<T>::g() { } // error: no matching declaration for S<T>
 template<typename T> requires C<T>      // ill-formed, no diagnostic required: template-head{s} are
 void S<T>::h() { }                      // functionally equivalent but not equivalent
@@ -82,13 +84,15 @@ template<C X> template<D Y>
 struct S<X>::Inner { };                 // OK
 ```
 — *end example*]
-In a redeclaration, partial specialization, explicit specialization or
-explicit instantiation of a class template, the *class-key* shall agree
-in kind with the original class template declaration [[dcl.type.elab]].
 #### Member functions of class templates <a id="temp.mem.func">[[temp.mem.func]]</a>
 A member function of a class template may be defined outside of the
 class template definition in which it is declared.
@@ -105,11 +109,11 @@ public:
   T& elem(int i) { return v[i]; }
 };
 ```
 declares three member functions of a class template. The subscript
-function might be defined like this:
 ``` cpp
 template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
   return v[i];
@@ -158,12 +162,12 @@ v2[3] = dcomplex(7,8);                  // Array<dcomplex>::operator[]
 #### Deduction guides <a id="temp.deduct.guide">[[temp.deduct.guide]]</a>
 Deduction guides are used when a *template-name* appears as a type
 specifier for a deduced class type [[dcl.type.class.deduct]]. Deduction
 guides are not found by name lookup. Instead, when performing class
-template argument deduction [[over.match.class.deduct]], any deduction
-guides declared for the class template are considered.
 ``` bnf
 deduction-guide:
     explicit-specifierₒₚₜ template-name '(' parameter-declaration-clause ')' '->' simple-template-id ';'
 ```
@@ -189,15 +193,15 @@ S x{A()};           // x is of type S<short, int>
 The same restrictions apply to the *parameter-declaration-clause* of a
 deduction guide as in a function declaration [[dcl.fct]]. The
 *simple-template-id* shall name a class template specialization. The
 *template-name* shall be the same *identifier* as the *template-name* of
-the *simple-template-id*. A *deduction-guide* shall be declared in the
-same scope as the corresponding class template and, for a member class
-template, with the same access. Two deduction guide declarations in the
-same translation unit for the same class template shall not have
-equivalent *parameter-declaration-clause*s.
 #### Member classes of class templates <a id="temp.mem.class">[[temp.mem.class]]</a>
 A member class of a class template may be defined outside the class
 template definition in which it is declared.
@@ -209,13 +213,13 @@ instantiation [[temp.inst]]. For example,
 ``` cpp
 template<class T> struct A {
   class B;
 };
-A<int>::B* b1;                          // OK: requires A to be defined but not A::B
 template<class T> class A<T>::B { };
-A<int>::B  b2;                          // OK: requires A::B to be defined
 ```
 — *end note*]
 #### Static data members of class templates <a id="temp.static">[[temp.static]]</a>
@@ -251,11 +255,11 @@ of unknown bound can have a different bound from its definition, if any.
 ``` cpp
 template <class T> struct A {
   static int i[];
 };
 template <class T> int A<T>::i[4];      // 4 elements
-template <> int A<int>::i[] = { 1 };    // OK: 1 element
 ```
 — *end example*]
 #### Enumeration members of class templates <a id="temp.mem.enum">[[temp.mem.enum]]</a>

 ### Class templates <a id="temp.class">[[temp.class]]</a>
+#### General <a id="temp.class.general">[[temp.class.general]]</a>
 A *class template* defines the layout and operations for an unbounded
 set of related types.
 [*Example 1*:
+It is possible for a single class template `List` to provide an
+unbounded set of class definitions: one class `List<T>` for every type
+`T`, each describing a linked list of elements of type `T`. Similarly, a
+class template `Array` describing a contiguous, dynamic array can be
+defined like this:
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
   T& elem(int i) { return v[i]; }
 };
 ```
 The prefix `template<class T>` specifies that a template is being
+declared and that a *type-name* `T` can be used in the declaration. In
 other words, `Array` is a parameterized type with `T` as its parameter.
 — *end example*]
+[*Note 1*:
+When a member of a class template is defined outside of the class
+template definition, the member definition is defined as a template
+definition with the *template-head* equivalent to that of the class
+template. The names of the template parameters used in the definition of
+the member can differ from the template parameter names used in the
+class template definition. The class template name in the member
+definition is followed by the template argument list of the
+*template-head* [[temp.arg]].
 [*Example 2*:
 ``` cpp
 template<class T1, class T2> struct A {
   void g();
   void h();
   template<D U> struct Inner;
 };
+template<C A> void S<A>::f() { }        // OK, template-head{s} match
 template<typename T> void S<T>::g() { } // error: no matching declaration for S<T>
 template<typename T> requires C<T>      // ill-formed, no diagnostic required: template-head{s} are
 void S<T>::h() { }                      // functionally equivalent but not equivalent
 struct S<X>::Inner { };                 // OK
 ```
 — *end example*]
+— *end note*]
+In a partial specialization, explicit specialization or explicit
+instantiation of a class template, the *class-key* shall agree in kind
+with the original class template declaration [[dcl.type.elab]].
 #### Member functions of class templates <a id="temp.mem.func">[[temp.mem.func]]</a>
 A member function of a class template may be defined outside of the
 class template definition in which it is declared.
   T& elem(int i) { return v[i]; }
 };
 ```
 declares three member functions of a class template. The subscript
+function can be defined like this:
 ``` cpp
 template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
   return v[i];
 #### Deduction guides <a id="temp.deduct.guide">[[temp.deduct.guide]]</a>
 Deduction guides are used when a *template-name* appears as a type
 specifier for a deduced class type [[dcl.type.class.deduct]]. Deduction
 guides are not found by name lookup. Instead, when performing class
+template argument deduction [[over.match.class.deduct]], all reachable
+deduction guides declared for the class template are considered.
 ``` bnf
 deduction-guide:
     explicit-specifierₒₚₜ template-name '(' parameter-declaration-clause ')' '->' simple-template-id ';'
 ```
 The same restrictions apply to the *parameter-declaration-clause* of a
 deduction guide as in a function declaration [[dcl.fct]]. The
 *simple-template-id* shall name a class template specialization. The
 *template-name* shall be the same *identifier* as the *template-name* of
+the *simple-template-id*. A *deduction-guide* shall inhabit the scope to
+which the corresponding class template belongs and, for a member class
+template, have the same access. Two deduction guide declarations for the
+same class template shall not have equivalent
+*parameter-declaration-clause*s if either is reachable from the other.
 #### Member classes of class templates <a id="temp.mem.class">[[temp.mem.class]]</a>
 A member class of a class template may be defined outside the class
 template definition in which it is declared.
 ``` cpp
 template<class T> struct A {
   class B;
 };
+A<int>::B* b1;                          // OK, requires A to be defined but not A::B
 template<class T> class A<T>::B { };
+A<int>::B  b2;                          // OK, requires A::B to be defined
 ```
 — *end note*]
 #### Static data members of class templates <a id="temp.static">[[temp.static]]</a>
 ``` cpp
 template <class T> struct A {
   static int i[];
 };
 template <class T> int A<T>::i[4];      // 4 elements
+template <> int A<int>::i[] = { 1 };    // OK, 1 element
 ```
 — *end example*]
 #### Enumeration members of class templates <a id="temp.mem.enum">[[temp.mem.enum]]</a>

Diff to HTML by rtfpessoa