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

Files changed (1) hide show

tmp/tmp79fy28jb/{from.md → to.md} +97 -17

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

@@ -28,18 +28,18 @@ 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-parameter*s are those of the
-class template. 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 {
@@ -59,16 +59,36 @@ template<class ... Types> struct B {
 template<class ... Types> void B<Types ...>::f3() { }   // OK
 template<class ... Types> void B<Types>::f4() { }       // error
 ```
 — *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.
@@ -84,50 +104,110 @@ public:
   T& operator[](int);
   T& elem(int i) { return v[i]; }
 };
 ```
-declares three function templates. 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];
 }
 ```
 — *end example*]
 The *template-argument*s for a member function of a class template are
 determined by the *template-argument*s of the type of the object for
 which the member function is called.
 [*Example 2*:
-The *template-argument* for `Array<T>::operator[]()` will be determined
-by the `Array` to which the subscripting operation is applied.
 ``` cpp
 Array<int> v1(20);
 Array<dcomplex> v2(30);
-v1[3] = 7; // Array<int>::operator[]()
-v2[3] = dcomplex(7,8); // Array<dcomplex>::operator[]()
 ```
 — *end example*]
 #### 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.
 [*Note 1*:
 The member class must be defined before its first use that requires an
-instantiation ([[temp.inst]]). For example,
 ``` cpp
 template<class T> struct A {
   class B;
 };

 — *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 {
 template<class ... Types> void B<Types ...>::f3() { }   // OK
 template<class ... Types> void B<Types>::f4() { }       // error
 ```
+``` cpp
+template<typename T> concept C = true;
+template<typename T> concept D = true;
+template<C T> struct S {
+  void f();
+  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
+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.
   T& operator[](int);
   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];
 }
 ```
+A constrained member function can be defined out of line:
+``` cpp
+template<typename T> concept C = requires {
+  typename T::type;
+};
+template<typename T> struct S {
+  void f() requires C<T>;
+  void g() requires C<T>;
+};
+template<typename T>
+  void S<T>::f() requires C<T> { }      // OK
+template<typename T>
+  void S<T>::g() { }                    // error: no matching function in S<T>
+```
 — *end example*]
 The *template-argument*s for a member function of a class template are
 determined by the *template-argument*s of the type of the object for
 which the member function is called.
 [*Example 2*:
+The *template-argument* for `Array<T>::operator[]` will be determined by
+the `Array` to which the subscripting operation is applied.
 ``` cpp
 Array<int> v1(20);
 Array<dcomplex> v2(30);
+v1[3] = 7; // Array<int>::operator[]
+v2[3] = dcomplex(7,8); // Array<dcomplex>::operator[]
 ```
 — *end example*]
+#### 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 ';'
+```
+[*Example 1*:
+``` cpp
+template<class T, class D = int>
+struct S {
+  T data;
+};
+template<class U>
+S(U) -> S<typename U::type>;
+struct A {
+  using type = short;
+  operator type();
+};
+S x{A()};           // x is of type S<short, int>
+```
+— *end example*]
+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.
 [*Note 1*:
 The member class must be defined before its first use that requires an
+instantiation [[temp.inst]]. For example,
 ``` cpp
 template<class T> struct A {
   class B;
 };

Diff to HTML by rtfpessoa