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

Files changed (1) hide show

tmp/tmpwnnlqd4d/{from.md → to.md} +104 -231

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

@@ -1,24 +1,24 @@
-# Member access control <a id="class.access">[[class.access]]</a>
 A member of a class can be
-- `private`; that is, its name can be used only by members and friends
- of the class in which it is declared.
-- `protected`; that is, its name can be used only by members and friends
   of the class in which it is declared, by classes derived from that
   class, and by their friends (see  [[class.protected]]).
-- `public`; that is, its name can be used anywhere without access
   restriction.
 A member of a class can also access all the names to which the class has
 access. A local class of a member function may access the same names
-that the member function itself may access.[^7]
 Members of a class defined with the keyword `class` are `private` by
 default. Members of a class defined with the keywords `struct` or
-`union` are `public` by default.
 [*Example 1*:
 ``` cpp
 class X {
@@ -33,13 +33,13 @@ struct S {
 — *end example*]
 Access control is applied uniformly to all names, whether the names are
 referred to from declarations or expressions.
-[*Note 1*: Access control applies to names nominated by `friend`
-declarations ([[class.friend]]) and *using-declaration*s (
-[[namespace.udecl]]). — *end note*]
 In the case of overloaded function names, access control is applied to
 the function selected by overload resolution.
 [*Note 2*:
@@ -62,25 +62,26 @@ void f() {
 }
 ```
 — *end note*]
-It should be noted that it is *access* to members and base classes that
-is controlled, not their *visibility*. Names of members are still
-visible, and implicit conversions to base classes are still considered,
-when those members and base classes are inaccessible. The interpretation
-of a given construct is established without regard to access control. If
-the interpretation established makes use of inaccessible member names or
-base classes, the construct is ill-formed.
-All access controls in Clause  [[class.access]] affect the ability to
-access a class member name from the declaration of a particular entity,
-including parts of the declaration preceding the name of the entity
-being declared and, if the entity is a class, the definitions of members
-of the class appearing outside the class’s *member-specification*.
-[*Note 3*: This access also applies to implicit references to
 constructors, conversion functions, and destructors. — *end note*]
 [*Example 2*:
 ``` cpp
@@ -114,17 +115,17 @@ is as the return type of a member of class `A`. Similarly, the use of
 `A`, so checking of *base-specifier*s must be deferred until the entire
 *base-specifier-list* has been seen.
 — *end example*]
-The names in a default argument ([[dcl.fct.default]]) are bound at the
 point of declaration, and access is checked at that point rather than at
 any points of use of the default argument. Access checking for default
 arguments in function templates and in member functions of class
 templates is performed as described in  [[temp.inst]].
-The names in a default *template-argument* ([[temp.param]]) have their
 access checked in the context in which they appear rather than at any
 points of use of the default *template-argument*.
 [*Example 3*:
@@ -141,15 +142,19 @@ class D : public U { };
 D <C<B> >* d;       // access error, C::TT is protected
 ```
 — *end example*]
-## Access specifiers <a id="class.access.spec">[[class.access.spec]]</a>
-Member declarations can be labeled by an *access-specifier* (Clause
 [[class.derived]]):
 An *access-specifier* specifies the access rules for members following
 it until the end of the class or until another *access-specifier* is
 encountered.
 [*Example 1*:
@@ -183,11 +188,11 @@ public:
 ```
 — *end example*]
 [*Note 1*: The effect of access control on the order of allocation of
-data members is described in  [[class.mem]]. — *end note*]
 When a member is redeclared within its class definition, the access
 specified at its redeclaration shall be the same as at its initial
 declaration.
@@ -222,23 +227,23 @@ class C : public B {
 };
 ```
 — *end example*]
-## Accessibility of base classes and base class members <a id="class.access.base">[[class.access.base]]</a>
-If a class is declared to be a base class (Clause  [[class.derived]])
-for another class using the `public` access specifier, the `public`
-members of the base class are accessible as `public` members of the
-derived class and `protected` members of the base class are accessible
-as `protected` members of the derived class. If a class is declared to
-be a base class for another class using the `protected` access
-specifier, the `public` and `protected` members of the base class are
-accessible as `protected` members of the derived class. If a class is
-declared to be a base class for another class using the `private` access
-specifier, the `public` and `protected` members of the base class are
-accessible as `private` members of the derived class[^8].
 In the absence of an *access-specifier* for a base class, `public` is
 assumed when the derived class is defined with the *class-key* `struct`
 and `private` is assumed when the class is defined with the *class-key*
 `class`.
@@ -264,14 +269,15 @@ Here `B` is a public base of `D2`, `D4`, and `D6`, a private base of
 [*Note 1*:
 A member of a private base class might be inaccessible as an inherited
 member name, but accessible directly. Because of the rules on pointer
-conversions ([[conv.ptr]]) and explicit casts ([[expr.cast]]), a
-conversion from a pointer to a derived class to a pointer to an
-inaccessible base class might be ill-formed if an implicit conversion is
-used, but well-formed if an explicit cast is used. For example,
 ``` cpp
 class B {
 public:
   int mi;                       // non-static member
@@ -343,12 +349,12 @@ immediate base class of `X`. — *end note*]
 The access to a member is affected by the class in which the member is
 named. This naming class is the class in which the member name was
 looked up and found.
 [*Note 3*: This class can be explicit, e.g., when a *qualified-id* is
-used, or implicit, e.g., when a class member access operator (
-[[expr.ref]]) is used (including cases where an implicit “`this->`” is
 added). If both a class member access operator and a *qualified-id* are
 used to name the member (as in `p->T::m`), the class naming the member
 is the class denoted by the *nested-name-specifier* of the
 *qualified-id* (that is, `T`). — *end note*]
@@ -385,11 +391,11 @@ in the “`.`” operator case) cannot be implicitly converted to a pointer
 to the naming class of the right operand.
 [*Note 4*: This requirement is in addition to the requirement that the
 member be accessible as named. — *end note*]
-## 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
@@ -471,26 +477,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;
@@ -515,16 +520,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 {
@@ -535,12 +541,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 {
@@ -549,23 +555,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*:
@@ -592,13 +598,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
@@ -619,27 +625,27 @@ 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*]
-## Protected member access <a id="class.protected">[[class.protected]]</a>
-An additional access check beyond those described earlier in Clause
 [[class.access]] is applied when a non-static data member or non-static
-member function is a protected member of its naming class (
-[[class.access.base]])[^9] As described earlier, access to a protected
 member is granted because the reference occurs in a friend or member of
-some class `C`. If the access is to form a pointer to member (
-[[expr.unary.op]]), the *nested-name-specifier* shall denote `C` or a
 class derived from `C`. All other accesses involve a (possibly implicit)
-object expression ([[expr.ref]]). In this case, the class of the object
 expression shall be `C` or a class derived from `C`.
 [*Example 1*:
 ``` cpp
@@ -656,45 +662,45 @@ class D2 : public B {
   friend void fr(B*,D1*,D2*);
   void mem(B*,D1*);
 };
 void fr(B* pb, D1* p1, D2* p2) {
-  pb->i = 1;                    // ill-formed
-  p1->i = 2;                    // ill-formed
   p2->i = 3;                    // OK (access through a D2)
   p2->B::i = 4;                 // OK (access through a D2, even though naming class is B)
-  int B::* pmi_B = &B::i;       // ill-formed
   int B::* pmi_B2 = &D2::i;     // OK (type of &D2::i is int B::*)
-  B::j = 5;                     // ill-formed (not a friend of naming class B)
   D2::j = 6;                    // OK (because refers to static member)
 }
 void D2::mem(B* pb, D1* p1) {
-  pb->i = 1;                    // ill-formed
-  p1->i = 2;                    // ill-formed
   i = 3;                        // OK (access through this)
   B::i = 4;                     // OK (access through this, qualification ignored)
-  int B::* pmi_B = &B::i;       // ill-formed
   int B::* pmi_B2 = &D2::i;     // OK
   j = 5;                        // OK (because j refers to static member)
   B::j = 6;                     // OK (because B::j refers to static member)
 }
 void g(B* pb, D1* p1, D2* p2) {
-  pb->i = 1;                    // ill-formed
-  p1->i = 2;                    // ill-formed
-  p2->i = 3;                    // ill-formed
 }
 ```
 — *end example*]
-## Access to virtual functions <a id="class.access.virt">[[class.access.virt]]</a>
-The access rules (Clause  [[class.access]]) for a virtual function are
-determined by its declaration and are not affected by the rules for a
-function that later overrides it.
 [*Example 1*:
 ``` cpp
 class B {
@@ -722,11 +728,11 @@ void f() {
 Access is checked at the call point using the type of the expression
 used to denote the object for which the member function is called (`B*`
 in the example above). The access of the member function in the class in
 which it was defined (`D` in the example above) is in general not known.
-## Multiple access <a id="class.paths">[[class.paths]]</a>
 If a name can be reached by several paths through a multiple inheritance
 graph, the access is that of the path that gives most access.
 [*Example 1*:
@@ -743,16 +749,16 @@ class C : public A, public B {
 Since `W::f()` is available to `C::f()` along the public path through
 `B`, access is allowed.
 — *end example*]
-## Nested classes <a id="class.access.nest">[[class.access.nest]]</a>
 A nested class is a member and as such has the same access rights as any
 other member. The members of an enclosing class have no special access
-to members of a nested class; the usual access rules (Clause
-[[class.access]]) shall be obeyed.
 [*Example 1*:
 ``` cpp
 class E {
@@ -773,138 +779,5 @@ class E {
 };
 ```
 — *end example*]
-<!-- Link reference definitions -->
-[basic.compound]: basic.md#basic.compound
-[basic.def.odr]: basic.md#basic.def.odr
-[basic.fundamental]: basic.md#basic.fundamental
-[basic.life]: basic.md#basic.life
-[basic.link]: basic.md#basic.link
-[basic.lookup]: basic.md#basic.lookup
-[basic.lookup.elab]: basic.md#basic.lookup.elab
-[basic.lookup.qual]: basic.md#basic.lookup.qual
-[basic.lookup.unqual]: basic.md#basic.lookup.unqual
-[basic.scope]: basic.md#basic.scope
-[basic.scope.class]: basic.md#basic.scope.class
-[basic.scope.hiding]: basic.md#basic.scope.hiding
-[basic.start.dynamic]: basic.md#basic.start.dynamic
-[basic.start.static]: basic.md#basic.start.static
-[basic.start.term]: basic.md#basic.start.term
-[basic.stc]: basic.md#basic.stc
-[basic.types]: basic.md#basic.types
-[c.strings]: strings.md#c.strings
-[class]: #class
-[class.abstract]: #class.abstract
-[class.access]: #class.access
-[class.access.base]: #class.access.base
-[class.access.nest]: #class.access.nest
-[class.access.spec]: #class.access.spec
-[class.access.virt]: #class.access.virt
-[class.base.init]: special.md#class.base.init
-[class.bit]: #class.bit
-[class.cdtor]: special.md#class.cdtor
-[class.copy]: special.md#class.copy
-[class.ctor]: special.md#class.ctor
-[class.derived]: #class.derived
-[class.dtor]: special.md#class.dtor
-[class.free]: special.md#class.free
-[class.friend]: #class.friend
-[class.local]: #class.local
-[class.mem]: #class.mem
-[class.member.lookup]: #class.member.lookup
-[class.mfct]: #class.mfct
-[class.mfct.non-static]: #class.mfct.non-static
-[class.mi]: #class.mi
-[class.name]: #class.name
-[class.nest]: #class.nest
-[class.nested.type]: #class.nested.type
-[class.paths]: #class.paths
-[class.protected]: #class.protected
-[class.static]: #class.static
-[class.static.data]: #class.static.data
-[class.static.mfct]: #class.static.mfct
-[class.this]: #class.this
-[class.union]: #class.union
-[class.union.anon]: #class.union.anon
-[class.virtual]: #class.virtual
-[conv.mem]: conv.md#conv.mem
-[conv.ptr]: conv.md#conv.ptr
-[dcl.enum]: dcl.md#dcl.enum
-[dcl.fct]: dcl.md#dcl.fct
-[dcl.fct.def]: dcl.md#dcl.fct.def
-[dcl.fct.def.delete]: dcl.md#dcl.fct.def.delete
-[dcl.fct.default]: dcl.md#dcl.fct.default
-[dcl.fct.spec]: dcl.md#dcl.fct.spec
-[dcl.init.aggr]: dcl.md#dcl.init.aggr
-[dcl.init.ref]: dcl.md#dcl.init.ref
-[dcl.inline]: dcl.md#dcl.inline
-[dcl.stc]: dcl.md#dcl.stc
-[dcl.type.cv]: dcl.md#dcl.type.cv
-[dcl.type.elab]: dcl.md#dcl.type.elab
-[dcl.typedef]: dcl.md#dcl.typedef
-[depr.static_constexpr]: future.md#depr.static_constexpr
-[expr.ass]: expr.md#expr.ass
-[expr.call]: expr.md#expr.call
-[expr.cast]: expr.md#expr.cast
-[expr.const]: expr.md#expr.const
-[expr.eq]: expr.md#expr.eq
-[expr.prim]: expr.md#expr.prim
-[expr.prim.this]: expr.md#expr.prim.this
-[expr.ref]: expr.md#expr.ref
-[expr.static.cast]: expr.md#expr.static.cast
-[expr.unary.op]: expr.md#expr.unary.op
-[fig:nonvirt]: #fig:nonvirt
-[fig:virt]: #fig:virt
-[fig:virtnonvirt]: #fig:virtnonvirt
-[intro.object]: intro.md#intro.object
-[namespace.def]: dcl.md#namespace.def
-[namespace.udecl]: dcl.md#namespace.udecl
-[over]: over.md#over
-[over.ass]: over.md#over.ass
-[over.load]: over.md#over.load
-[over.match]: over.md#over.match
-[over.match.call]: over.md#over.match.call
-[over.match.funcs]: over.md#over.match.funcs
-[over.oper]: over.md#over.oper
-[string.classes]: strings.md#string.classes
-[temp]: temp.md#temp
-[temp.arg]: temp.md#temp.arg
-[temp.dep.type]: temp.md#temp.dep.type
-[temp.friend]: temp.md#temp.friend
-[temp.inst]: temp.md#temp.inst
-[temp.mem]: temp.md#temp.mem
-[temp.param]: temp.md#temp.param
-[temp.spec]: temp.md#temp.spec
-[temp.variadic]: temp.md#temp.variadic
-[^1]: Base class subobjects are not so constrained.
-[^2]: This ensures that two subobjects that have the same class type and
-    that belong to the same most derived object are not allocated at the
-    same address ([[expr.eq]]).
-[^3]: The acronym POD stands for “plain old data”.
-[^4]: See, for example, `<cstring>` ([[c.strings]]).
-[^5]: A function with the same name but a different parameter list
-    (Clause  [[over]]) as a virtual function is not necessarily virtual
-    and does not override. The use of the `virtual` specifier in the
-    declaration of an overriding function is legal but redundant (has
-    empty semantics). Access control (Clause  [[class.access]]) is not
-    considered in determining overriding.
-[^6]: Multi-level pointers to classes or references to multi-level
-    pointers to classes are not allowed.
-[^7]: Access permissions are thus transitive and cumulative to nested
-    and local classes.
-[^8]: As specified previously in Clause  [[class.access]], private
-    members of a base class remain inaccessible even to derived classes
-    unless `friend` declarations within the base class definition are
-    used to grant access explicitly.
-[^9]: This additional check does not apply to other members, e.g.,
-    static data members or enumerator member constants.

+## Member access control <a id="class.access">[[class.access]]</a>
 A member of a class can be
+- private; that is, its name can be used only by members and friends of
+  the class in which it is declared.
+- protected; that is, its name can be used only by members and friends
   of the class in which it is declared, by classes derived from that
   class, and by their friends (see  [[class.protected]]).
+- public; that is, its name can be used anywhere without access
   restriction.
 A member of a class can also access all the names to which the class has
 access. A local class of a member function may access the same names
+that the member function itself may access.[^11]
 Members of a class defined with the keyword `class` are `private` by
 default. Members of a class defined with the keywords `struct` or
+`union` are public by default.
 [*Example 1*:
 ``` cpp
 class X {
 — *end example*]
 Access control is applied uniformly to all names, whether the names are
 referred to from declarations or expressions.
+[*Note 1*: Access control applies to names nominated by friend
+declarations [[class.friend]] and *using-declaration*s
+[[namespace.udecl]]. — *end note*]
 In the case of overloaded function names, access control is applied to
 the function selected by overload resolution.
 [*Note 2*:
 }
 ```
 — *end note*]
+[*Note 3*: Access to members and base classes is controlled, not their
+visibility [[basic.scope.hiding]]. Names of members are still visible,
+and implicit conversions to base classes are still considered, when
+those members and base classes are inaccessible. — *end note*]
+The interpretation of a given construct is established without regard to
+access control. If the interpretation established makes use of
+inaccessible member names or base classes, the construct is ill-formed.
+All access controls in [[class.access]] affect the ability to access a
+class member name from the declaration of a particular entity, including
+parts of the declaration preceding the name of the entity being declared
+and, if the entity is a class, the definitions of members of the class
+appearing outside the class’s *member-specification*.
+[*Note 4*: This access also applies to implicit references to
 constructors, conversion functions, and destructors. — *end note*]
 [*Example 2*:
 ``` cpp
 `A`, so checking of *base-specifier*s must be deferred until the entire
 *base-specifier-list* has been seen.
 — *end example*]
+The names in a default argument [[dcl.fct.default]] are bound at the
 point of declaration, and access is checked at that point rather than at
 any points of use of the default argument. Access checking for default
 arguments in function templates and in member functions of class
 templates is performed as described in  [[temp.inst]].
+The names in a default *template-argument* [[temp.param]] have their
 access checked in the context in which they appear rather than at any
 points of use of the default *template-argument*.
 [*Example 3*:
 D <C<B> >* d;       // access error, C::TT is protected
 ```
 — *end example*]
+### Access specifiers <a id="class.access.spec">[[class.access.spec]]</a>
+Member declarations can be labeled by an *access-specifier* (
 [[class.derived]]):
+``` bnf
+access-specifier ':' member-specificationₒₚₜ
+```
 An *access-specifier* specifies the access rules for members following
 it until the end of the class or until another *access-specifier* is
 encountered.
 [*Example 1*:
 ```
 — *end example*]
 [*Note 1*: The effect of access control on the order of allocation of
+data members is specified in  [[expr.rel]]. — *end note*]
 When a member is redeclared within its class definition, the access
 specified at its redeclaration shall be the same as at its initial
 declaration.
 };
 ```
 — *end example*]
+### Accessibility of base classes and base class members <a id="class.access.base">[[class.access.base]]</a>
+If a class is declared to be a base class [[class.derived]] for another
+class using the `public` access specifier, the public members of the
+base class are accessible as public members of the derived class and
+protected members of the base class are accessible as protected members
+of the derived class. If a class is declared to be a base class for
+another class using the `protected` access specifier, the public and
+protected members of the base class are accessible as protected members
+of the derived class. If a class is declared to be a base class for
+another class using the `private` access specifier, the public and
+protected members of the base class are accessible as private members of
+the derived class.[^12]
 In the absence of an *access-specifier* for a base class, `public` is
 assumed when the derived class is defined with the *class-key* `struct`
 and `private` is assumed when the class is defined with the *class-key*
 `class`.
 [*Note 1*:
 A member of a private base class might be inaccessible as an inherited
 member name, but accessible directly. Because of the rules on pointer
+conversions [[conv.ptr]] and explicit casts ([[expr.type.conv]],
+[[expr.static.cast]], [[expr.cast]]), a conversion from a pointer to a
+derived class to a pointer to an inaccessible base class might be
+ill-formed if an implicit conversion is used, but well-formed if an
+explicit cast is used. For example,
 ``` cpp
 class B {
 public:
   int mi;                       // non-static member
 The access to a member is affected by the class in which the member is
 named. This naming class is the class in which the member name was
 looked up and found.
 [*Note 3*: This class can be explicit, e.g., when a *qualified-id* is
+used, or implicit, e.g., when a class member access operator
+[[expr.ref]] is used (including cases where an implicit “`this->`” is
 added). If both a class member access operator and a *qualified-id* are
 used to name the member (as in `p->T::m`), the class naming the member
 is the class denoted by the *nested-name-specifier* of the
 *qualified-id* (that is, `T`). — *end note*]
 to the naming class of the right operand.
 [*Note 4*: This requirement is in addition to the requirement that the
 member be accessible as named. — *end note*]
+### 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*]
+### Protected member access <a id="class.protected">[[class.protected]]</a>
+An additional access check beyond those described earlier in
 [[class.access]] is applied when a non-static data member or non-static
+member function is a protected member of its naming class
+[[class.access.base]].[^13] As described earlier, access to a protected
 member is granted because the reference occurs in a friend or member of
+some class `C`. If the access is to form a pointer to member
+[[expr.unary.op]], the *nested-name-specifier* shall denote `C` or a
 class derived from `C`. All other accesses involve a (possibly implicit)
+object expression [[expr.ref]]. In this case, the class of the object
 expression shall be `C` or a class derived from `C`.
 [*Example 1*:
 ``` cpp
   friend void fr(B*,D1*,D2*);
   void mem(B*,D1*);
 };
 void fr(B* pb, D1* p1, D2* p2) {
+  pb->i = 1;                    // error
+  p1->i = 2;                    // error
   p2->i = 3;                    // OK (access through a D2)
   p2->B::i = 4;                 // OK (access through a D2, even though naming class is B)
+  int B::* pmi_B = &B::i;       // error
   int B::* pmi_B2 = &D2::i;     // OK (type of &D2::i is int B::*)
+  B::j = 5;                     // error: not a friend of naming class B
   D2::j = 6;                    // OK (because refers to static member)
 }
 void D2::mem(B* pb, D1* p1) {
+  pb->i = 1;                    // error
+  p1->i = 2;                    // error
   i = 3;                        // OK (access through this)
   B::i = 4;                     // OK (access through this, qualification ignored)
+  int B::* pmi_B = &B::i;       // error
   int B::* pmi_B2 = &D2::i;     // OK
   j = 5;                        // OK (because j refers to static member)
   B::j = 6;                     // OK (because B::j refers to static member)
 }
 void g(B* pb, D1* p1, D2* p2) {
+  pb->i = 1;                    // error
+  p1->i = 2;                    // error
+  p2->i = 3;                    // error
 }
 ```
 — *end example*]
+### Access to virtual functions <a id="class.access.virt">[[class.access.virt]]</a>
+The access rules [[class.access]] for a virtual function are determined
+by its declaration and are not affected by the rules for a function that
+later overrides it.
 [*Example 1*:
 ``` cpp
 class B {
 Access is checked at the call point using the type of the expression
 used to denote the object for which the member function is called (`B*`
 in the example above). The access of the member function in the class in
 which it was defined (`D` in the example above) is in general not known.
+### Multiple access <a id="class.paths">[[class.paths]]</a>
 If a name can be reached by several paths through a multiple inheritance
 graph, the access is that of the path that gives most access.
 [*Example 1*:
 Since `W::f()` is available to `C::f()` along the public path through
 `B`, access is allowed.
 — *end example*]
+### Nested classes <a id="class.access.nest">[[class.access.nest]]</a>
 A nested class is a member and as such has the same access rights as any
 other member. The members of an enclosing class have no special access
+to members of a nested class; the usual access rules [[class.access]]
+shall be obeyed.
 [*Example 1*:
 ``` cpp
 class E {
 };
 ```
 — *end example*]

Diff to HTML by rtfpessoa