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

Files changed (1) hide show

tmp/tmpkxdueucd/{from.md → to.md} +27 -27

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

@@ -1,6 +1,6 @@
-## Friends <a id="class.friend">[[class.friend]]</a>
 A friend of a class is a function or class that is given permission to
 use the private and protected member names from the class. A class
 specifies its friends, if any, by way of friend declarations. Such
 declarations give special access rights to the friends, but they do not
@@ -82,26 +82,25 @@ class A {
 };
 ```
 — *end example*]
-A `friend` declaration that does not declare a function shall have one
-of the following forms:
 ``` bnf
-'friend' elaborated-type-specifier ';'
-'friend' simple-type-specifier ';'
-'friend' typename-specifier ';'
 ```
-[*Note 1*: A `friend` declaration may be the *declaration* in a
-*template-declaration* (Clause  [[temp]],
-[[temp.friend]]). — *end note*]
 If the type specifier in a `friend` declaration designates a (possibly
 cv-qualified) class type, that class is declared as a friend; otherwise,
-the `friend` declaration is ignored.
 [*Example 5*:
 ``` cpp
 class C;
@@ -126,16 +125,17 @@ R<int> Ri;                      // OK: "friend int;" is ignored
 ```
 — *end example*]
 A function first declared in a friend declaration has the linkage of the
-namespace of which it is a member ([[basic.link]]). Otherwise, the
-function retains its previous linkage ([[dcl.stc]]).
-When a `friend` declaration refers to an overloaded name or operator,
-only the function specified by the parameter types becomes a friend. A
-member function of a class `X` can be a friend of a class `Y`.
 [*Example 6*:
 ``` cpp
 class Y {
@@ -146,12 +146,12 @@ class Y {
 ```
 — *end example*]
 A function can be defined in a friend declaration of a class if and only
-if the class is a non-local class ([[class.local]]), the function name
-is unqualified, and the function has namespace scope.
 [*Example 7*:
 ``` cpp
 class M {
@@ -160,23 +160,23 @@ class M {
 };
 ```
 — *end example*]
-Such a function is implicitly an inline function ([[dcl.inline]]). A
-`friend` function defined in a class is in the (lexical) scope of the
-class in which it is defined. A friend function defined outside the
-class is not ([[basic.lookup.unqual]]).
 No *storage-class-specifier* shall appear in the *decl-specifier-seq* of
 a friend declaration.
 A name nominated by a friend declaration shall be accessible in the
 scope of the class containing the friend declaration. The meaning of the
 friend declaration is the same whether the friend declaration appears in
-the `private`, `protected` or `public` ([[class.mem]]) portion of the
-class *member-specification*.
 Friendship is neither inherited nor transitive.
 [*Example 8*:
@@ -203,13 +203,13 @@ class D : public B  {
 };
 ```
 — *end example*]
-If a friend declaration appears in a local class ([[class.local]]) and
-the name specified is an unqualified name, a prior declaration is looked
-up without considering scopes that are outside the innermost enclosing
 non-class scope. For a friend function declaration, if there is no prior
 declaration, the program is ill-formed. For a friend class declaration,
 if there is no prior declaration, the class that is specified belongs to
 the innermost enclosing non-class scope, but if it is subsequently
 referenced, its name is not found by name lookup until a matching
@@ -230,11 +230,11 @@ void f() {
   friend void a();  // error, ::a is not considered
   friend void b();  // OK
   friend void c();  // error
   };
   X* px;            // OK, but ::X is found
-  Z* pz;            // error, no Z is found
 }
 ```
 — *end example*]

+### Friends <a id="class.friend">[[class.friend]]</a>
 A friend of a class is a function or class that is given permission to
 use the private and protected member names from the class. A class
 specifies its friends, if any, by way of friend declarations. Such
 declarations give special access rights to the friends, but they do not
 };
 ```
 — *end example*]
+A friend declaration that does not declare a function shall have one of
+the following forms:
 ``` bnf
+friend elaborated-type-specifier ';'
+friend simple-type-specifier ';'
+friend typename-specifier ';'
 ```
+[*Note 1*: A friend declaration may be the *declaration* in a
+*template-declaration* ([[temp.pre]], [[temp.friend]]). — *end note*]
 If the type specifier in a `friend` declaration designates a (possibly
 cv-qualified) class type, that class is declared as a friend; otherwise,
+the friend declaration is ignored.
 [*Example 5*:
 ``` cpp
 class C;
 ```
 — *end example*]
 A function first declared in a friend declaration has the linkage of the
+namespace of which it is a member ([[basic.link]],
+[[namespace.memdef]]). Otherwise, the function retains its previous
+linkage [[dcl.stc]].
+When a friend declaration refers to an overloaded name or operator, only
+the function specified by the parameter types becomes a friend. A member
+function of a class `X` can be a friend of a class `Y`.
 [*Example 6*:
 ``` cpp
 class Y {
 ```
 — *end example*]
 A function can be defined in a friend declaration of a class if and only
+if the class is a non-local class [[class.local]], the function name is
+unqualified, and the function has namespace scope.
 [*Example 7*:
 ``` cpp
 class M {
 };
 ```
 — *end example*]
+Such a function is implicitly an inline [[dcl.inline]] function if it is
+attached to the global module. A friend function defined in a class is
+in the (lexical) scope of the class in which it is defined. A friend
+function defined outside the class is not [[basic.lookup.unqual]].
 No *storage-class-specifier* shall appear in the *decl-specifier-seq* of
 a friend declaration.
 A name nominated by a friend declaration shall be accessible in the
 scope of the class containing the friend declaration. The meaning of the
 friend declaration is the same whether the friend declaration appears in
+the private, protected, or public [[class.mem]] portion of the class
+*member-specification*.
 Friendship is neither inherited nor transitive.
 [*Example 8*:
 };
 ```
 — *end example*]
+If a friend declaration appears in a local class [[class.local]] and the
+name specified is an unqualified name, a prior declaration is looked up
+without considering scopes that are outside the innermost enclosing
 non-class scope. For a friend function declaration, if there is no prior
 declaration, the program is ill-formed. For a friend class declaration,
 if there is no prior declaration, the class that is specified belongs to
 the innermost enclosing non-class scope, but if it is subsequently
 referenced, its name is not found by name lookup until a matching
   friend void a();  // error, ::a is not considered
   friend void b();  // OK
   friend void c();  // error
   };
   X* px;            // OK, but ::X is found
+  Z* pz;            // error: no Z is found
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa