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

Files changed (1) hide show

tmp/tmpqm7neyz2/{from.md → to.md} +37 -18

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

@@ -12,11 +12,11 @@ declaration that is not a template declaration:
   non-template function is found in the specified class or namespace,
   the friend declaration refers to that function, otherwise,
 - if the name of the friend is a *qualified-id* and a matching function
   template is found in the specified class or namespace, the friend
   declaration refers to the deduced specialization of that function
-  template ([[temp.deduct.decl]]), otherwise,
 - the name shall be an *unqualified-id* that declares (or redeclares) a
   non-template function.
 [*Example 1*:
@@ -67,13 +67,13 @@ class A {
 ```
 — *end example*]
 A template friend declaration specifies that all specializations of that
-template, whether they are implicitly instantiated ([[temp.inst]]),
-partially specialized ([[temp.class.spec]]) or explicitly specialized (
-[[temp.expl.spec]]), are friends of the class containing the template
 friend declaration.
 [*Example 3*:
 ``` cpp
@@ -86,52 +86,63 @@ template<class T> struct A { X::Y ab; };            // OK
 template<class T> struct A<T*> { X::Y ab; };        // OK
 ```
 — *end example*]
-A member of a class template may be declared to be a friend of a
-non-template class. In this case, the corresponding member of every
-specialization of the primary class template and class template partial
-specializations thereof is a friend of the class granting friendship.
-For explicit specializations and specializations of partial
-specializations, the corresponding member is the member (if any) that
-has the same name, kind (type, function, class template, or function
-template), template parameters, and signature as the member of the class
-template instantiation that would otherwise have been generated.
 [*Example 4*:
 ``` cpp
 template<class T> struct A {
   struct B { };
   void f();
   struct D {
     void g();
   };
 };
 template<> struct A<int> {
   struct B { };
   int f();
   struct D {
     void g();
   };
 };
 class C {
   template<class T> friend struct A<T>::B;      // grants friendship to A<int>::B even though
                                                 // it is not a specialization of A<T>::B
   template<class T> friend void A<T>::f();      // does not grant friendship to A<int>::f()
                                                 // because its return type does not match
-  template<class T> friend void A<T>::D::g();   // does not grant friendship to A<int>::D::g()
-                                                // because A<int>::D is not a specialization of A<T>::D
-};
 ```
 — *end example*]
 [*Note 1*: A friend declaration may first declare a member of an
-enclosing namespace scope ([[temp.inject]]). — *end note*]
 A friend template shall not be declared in a local class.
 Friend declarations shall not declare partial specializations.
@@ -146,7 +157,15 @@ class X {
 — *end example*]
 When a friend declaration refers to a specialization of a function
 template, the function parameter declarations shall not include default
-arguments, nor shall the inline specifier be used in such a declaration.

   non-template function is found in the specified class or namespace,
   the friend declaration refers to that function, otherwise,
 - if the name of the friend is a *qualified-id* and a matching function
   template is found in the specified class or namespace, the friend
   declaration refers to the deduced specialization of that function
+  template [[temp.deduct.decl]], otherwise,
 - the name shall be an *unqualified-id* that declares (or redeclares) a
   non-template function.
 [*Example 1*:
 ```
 — *end example*]
 A template friend declaration specifies that all specializations of that
+template, whether they are implicitly instantiated [[temp.inst]],
+partially specialized [[temp.class.spec]] or explicitly specialized
+[[temp.expl.spec]], are friends of the class containing the template
 friend declaration.
 [*Example 3*:
 ``` cpp
 template<class T> struct A<T*> { X::Y ab; };        // OK
 ```
 — *end example*]
+A template friend declaration may declare a member of a dependent type
+to be a friend. The friend declaration shall declare a function or
+specify a type with an *elaborated-type-specifier*, in either case with
+a *nested-name-specifier* ending with a *simple-template-id*, *C*, whose
+*template-name* names a class template. The template parameters of the
+template friend declaration shall be deducible from *C* (
+[[temp.deduct.type]]). In this case, a member of a specialization *S* of
+the class template is a friend of the class granting friendship if
+deduction of the template parameters of *C* from *S* succeeds, and
+substituting the deduced template arguments into the friend declaration
+produces a declaration that would be a valid redeclaration of the member
+of the specialization.
 [*Example 4*:
 ``` cpp
 template<class T> struct A {
   struct B { };
   void f();
   struct D {
     void g();
   };
+  T h();
+  template<T U> T i();
 };
 template<> struct A<int> {
   struct B { };
   int f();
   struct D {
     void g();
   };
+  template<int U> int i();
+};
+template<> struct A<float*> {
+  int *h();
 };
 class C {
   template<class T> friend struct A<T>::B;      // grants friendship to A<int>::B even though
                                                 // it is not a specialization of A<T>::B
   template<class T> friend void A<T>::f();      // does not grant friendship to A<int>::f()
                                                 // because its return type does not match
+  template<class T> friend void A<T>::D::g();   // error: A<T>::D does not end with a simple-template-id
+  template<class T> friend int *A<T*>::h();     // grants friendship to A<int*>::h() and A<float*>::h()
+  template<class T> template<T U>               // grants friendship to instantiations of A<T>::i() and
+    friend T A<T>::i();                         // to A<int>::i(), and thereby to all specializations
+};                                              // of those function templates
 ```
 — *end example*]
 [*Note 1*: A friend declaration may first declare a member of an
+enclosing namespace scope [[temp.inject]]. — *end note*]
 A friend template shall not be declared in a local class.
 Friend declarations shall not declare partial specializations.
 — *end example*]
 When a friend declaration refers to a specialization of a function
 template, the function parameter declarations shall not include default
+arguments, nor shall the `inline`, `constexpr`, or `consteval`
+specifiers be used in such a declaration.
+A non-template friend declaration with a *requires-clause* shall be a
+definition. A friend function template with a constraint that depends on
+a template parameter from an enclosing template shall be a definition.
+Such a constrained friend function or function template declaration does
+not declare the same function or function template as a declaration in
+any other scope.

Diff to HTML by rtfpessoa