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

Files changed (1) hide show

tmp/tmp4yjcc4r4/{from.md → to.md} +177 -138

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

@@ -1,20 +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.[^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.
@@ -30,61 +34,77 @@ 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*:
-Because access control applies to names, if access control is applied to
-a typedef name, only the accessibility of the typedef name itself is
-considered. The accessibility of the entity referred to by the typedef
-is not considered. For example,
 ``` cpp
 class A {
   class B { };
 public:
   typedef B BB;
 };
 void f() {
-  A::BB x;          // OK, typedef name A::BB is public
   A::B y;           // access error, A::B is private
 }
 ```
 — *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
 class A {
   typedef int I;    // private member
   I f();
@@ -115,21 +135,20 @@ 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*:
 ``` cpp
 class B { };
 template <class T> class C {
 protected:
@@ -144,12 +163,12 @@ 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ₒₚₜ
 ```
@@ -187,13 +206,10 @@ public:
 };
 ```
 — *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.
 [*Example 3*:
@@ -208,11 +224,11 @@ private:
 };
 ```
 — *end example*]
-[*Note 2*: In a derived class, the lookup of a base class name will
 find the injected-class-name instead of the name of the base class in
 the scope in which it was declared. The injected-class-name might be
 less accessible than the name of the base class in the scope in which it
 was declared. — *end note*]
@@ -267,17 +283,17 @@ Here `B` is a public base of `D2`, `D4`, and `D6`, a private base of
 — *end example*]
 [*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
@@ -296,24 +312,24 @@ void DD::f() {
   b.mi = 3;                     // OK (b.mi is different from this->mi)
   b.si = 3;                     // OK (b.si is different from this->si)
   ::B::si = 3;                  // OK
   ::B* bp1 = this;              // error: B is a private base class
   ::B* bp2 = (::B*)this;        // OK with cast
-  bp2->mi = 3;                  // OK: access through a pointer to B.
 }
 ```
 — *end note*]
 A base class `B` of `N` is *accessible* at *R*, if
 - an invented public member of `B` would be a public member of `N`, or
-- *R* occurs in a member or friend of class `N`, and an invented public
-  member of `B` would be a private or protected member of `N`, or
-- *R* occurs in a member or friend of a class `P` derived from `N`, and
-  an invented public member of `B` would be a private or protected
-  member of `P`, or
 - there exists a class `S` such that `B` is a base class of `S`
   accessible at *R* and `S` is a base class of `N` accessible at *R*.
 [*Example 2*:
@@ -337,20 +353,20 @@ class N: private S {
 ```
 — *end example*]
 If a base class is accessible, one can implicitly convert a pointer to a
-derived class to a pointer to that base class ([[conv.ptr]],
-[[conv.mem]]).
 [*Note 2*: It follows that members and friends of a class `X` can
 implicitly convert an `X*` to a pointer to a private or protected
 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
@@ -359,15 +375,15 @@ is the class denoted by the *nested-name-specifier* of the
 *qualified-id* (that is, `T`). — *end note*]
 A member `m` is accessible at the point *R* when named in class `N` if
 - `m` as a member of `N` is public, or
-- `m` as a member of `N` is private, and *R* occurs in a member or
-  friend of class `N`, or
-- `m` as a member of `N` is protected, and *R* occurs in a member or
-  friend of class `N`, or in a member of a class `P` derived from `N`,
-  where `m` as a member of `P` is public, private, or protected, or
 - there exists a base class `B` of `N` that is accessible at *R*, and
   `m` is accessible at *R* when named in class `B`.
   \[*Example 3*:
   ``` cpp
   class B;
@@ -376,11 +392,11 @@ A member `m` is accessible at the point *R* when named in class `N` if
     int i;
     friend void f(B*);
   };
   class B : public A { };
   void f(B* p) {
-    p->i = 1;         // OK: B* can be implicitly converted to A*, and f has access to i in A
   }
   ```
   — *end example*]
@@ -394,14 +410,14 @@ to the naming class of the right operand.
 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
-make the nominated friends members of the befriending class.
 [*Example 1*:
 The following example illustrates the differences between members and
 friends:
@@ -424,26 +440,26 @@ void f() {
 }
 ```
 — *end example*]
-Declaring a class to be a friend implies that the names of private and
-protected members from the class granting friendship can be accessed in
-the *base-specifier*s and member declarations of the befriended class.
 [*Example 2*:
 ``` cpp
 class A {
   class B { };
   friend class X;
 };
-struct X : A::B {               // OK: A::B accessible to friend
-  A::B mx;                      // OK: A::B accessible to member of friend
   class Y {
-    A::B my;                    // OK: A::B accessible to nested member of friend
   };
 };
 ```
 — *end example*]
@@ -465,74 +481,62 @@ class Z {
 };
 ```
 — *end example*]
-A class shall not be defined in a friend declaration.
-[*Example 4*:
-``` cpp
-class A {
-  friend class B { };           // error: cannot define class in friend declaration
-};
-```
-— *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;
 typedef C Ct;
 class X1 {
-  friend C;                     // OK: class C is a friend
 };
 class X2 {
-  friend Ct;                    // OK: class C is a friend
-  friend D;                     // error: no type-name D in scope
-  friend class D;               // OK: elaborated-type-specifier declares new class
 };
 template <typename T> class R {
   friend T;
 };
 R<C> rc;                        // class C is a friend of R<C>
-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]],
-[[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 {
   friend char* X::foo(int);
   friend X::X(char);            // constructors can be friends
@@ -540,15 +544,17 @@ 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 {
   friend void f() { }           // definition of global f, a friend of M,
                                 // not the definition of a member function
@@ -556,26 +562,27 @@ 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*:
 ``` cpp
 class A {
   friend class B;
   int a;
@@ -598,19 +605,48 @@ 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
-declaration is provided in the innermost enclosing non-class scope.
 [*Example 9*:
 ``` cpp
 class X;
@@ -636,17 +672,19 @@ void f() {
 ### 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
 class B {
@@ -716,11 +754,11 @@ private:
 void f() {
   D d;
   B* pb = &d;
   D* pd = &d;
-  pb->f();                      // OK: B::f() is public, D::f() is invoked
   pd->f();                      // error: D::f() is private
 }
 ```
 — *end example*]
@@ -730,12 +768,13 @@ 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*:
 ``` cpp
 class W { public: void f(); };
@@ -764,14 +803,14 @@ shall be obeyed.
 class E {
   int x;
   class B { };
   class I {
-    B b;                        // OK: E::I can access E::B
     int y;
     void f(E* p, int i) {
-      p->x = i;                 // OK: E::I can access E::x
     }
   };
   int g(I* p) {
     return p->y;                // error: I::y is private

 ## Member access control <a id="class.access">[[class.access]]</a>
+### General <a id="class.access.general">[[class.access.general]]</a>
 A member of a class can be
+- private, that is, it can be named only by members and friends of the
+  class in which it is declared;
+- protected, that is, it can be named 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]]); or
+- public, that is, it can be named anywhere without access restriction.
+[*Note 1*: A constructor or destructor can be named by an expression
+[[basic.def.odr]] even though it has no name. — *end note*]
+A member of a class can also access all the members to which the class
+has access. A local class of a member function may access the same
+members 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.
 };
 ```
 — *end example*]
+Access control is applied uniformly to declarations and expressions.
+[*Note 2*: Access control applies to members nominated by friend
 declarations [[class.friend]] and *using-declaration*s
 [[namespace.udecl]]. — *end note*]
+When a *using-declarator* is named, access control is applied to it, not
+to the declarations that replace it. For an overload set, access control
+is applied only to the function selected by overload resolution.
+[*Example 2*:
+``` cpp
+struct S {
+  void f(int);
+private:
+  void f(double);
+};
+void g(S* sp) {
+  sp->f(2);         // OK, access control applied after overload resolution
+}
+```
+— *end example*]
+[*Note 3*:
+Because access control applies to the declarations named, if access
+control is applied to a *typedef-name*, only the accessibility of the
+typedef or alias declaration itself is considered. The accessibility of
+the entity referred to by the *typedef-name* is not considered. For
+example,
 ``` cpp
 class A {
   class B { };
 public:
   typedef B BB;
 };
 void f() {
+  A::BB x;          // OK, typedef A::BB is public
   A::B y;           // access error, A::B is private
 }
 ```
 — *end note*]
+[*Note 4*: Access control does not prevent members from being found by
+name lookup or implicit conversions to base classes from being
+considered. — *end note*]
 The interpretation of a given construct is established without regard to
 access control. If the interpretation established makes use of
+inaccessible members or base classes, the construct is ill-formed.
+All access controls in [[class.access]] affect the ability to name a
+class member 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 5*: This access also applies to implicit references to
 constructors, conversion functions, and destructors. — *end note*]
+[*Example 3*:
 ``` cpp
 class A {
   typedef int I;    // private member
   I f();
 `A`, so checking of *base-specifier*s must be deferred until the entire
 *base-specifier-list* has been seen.
 — *end example*]
+Access is checked for a default argument [[dcl.fct.default]] at the
+point of declaration, 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]].
+Access for a default *template-argument* [[temp.param]] is checked in
+the context in which it appears rather than at any points of use of it.
+[*Example 4*:
 ``` cpp
 class B { };
 template <class T> class C {
 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ₒₚₜ
 ```
 };
 ```
 — *end example*]
 When a member is redeclared within its class definition, the access
 specified at its redeclaration shall be the same as at its initial
 declaration.
 [*Example 3*:
 };
 ```
 — *end example*]
+[*Note 1*: In a derived class, the lookup of a base class name will
 find the injected-class-name instead of the name of the base class in
 the scope in which it was declared. The injected-class-name might be
 less accessible than the name of the base class in the scope in which it
 was declared. — *end note*]
 — *end example*]
 [*Note 1*:
+A member of a private base class can be inaccessible as inherited, 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 can 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
   b.mi = 3;                     // OK (b.mi is different from this->mi)
   b.si = 3;                     // OK (b.si is different from this->si)
   ::B::si = 3;                  // OK
   ::B* bp1 = this;              // error: B is a private base class
   ::B* bp2 = (::B*)this;        // OK with cast
+  bp2->mi = 3;                  // OK, access through a pointer to B.
 }
 ```
 — *end note*]
 A base class `B` of `N` is *accessible* at *R*, if
 - an invented public member of `B` would be a public member of `N`, or
+- *R* occurs in a direct member or friend of class `N`, and an invented
+ public member of `B` would be a private or protected member of `N`, or
+- *R* occurs in a direct member or friend of a class `P` derived from
+ `N`, and an invented public member of `B` would be a private or
+ protected member of `P`, or
 - there exists a class `S` such that `B` is a base class of `S`
   accessible at *R* and `S` is a base class of `N` accessible at *R*.
 [*Example 2*:
 ```
 — *end example*]
 If a base class is accessible, one can implicitly convert a pointer to a
+derived class to a pointer to that base class
+[[conv.ptr]], [[conv.mem]].
 [*Note 2*: It follows that members and friends of a class `X` can
 implicitly convert an `X*` to a pointer to a private or protected
 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 whose scope name lookup
+performed a search that found the member.
 [*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
 *qualified-id* (that is, `T`). — *end note*]
 A member `m` is accessible at the point *R* when named in class `N` if
 - `m` as a member of `N` is public, or
+- `m` as a member of `N` is private, and *R* occurs in a direct member
+ or friend of class `N`, or
+- `m` as a member of `N` is protected, and *R* occurs in a direct member
+ or friend of class `N`, or in a member of a class `P` derived from
+ `N`, where `m` as a member of `P` is public, private, or protected, or
 - there exists a base class `B` of `N` that is accessible at *R*, and
   `m` is accessible at *R* when named in class `B`.
   \[*Example 3*:
   ``` cpp
   class B;
     int i;
     friend void f(B*);
   };
   class B : public A { };
   void f(B* p) {
+    p->i = 1;         // OK, B* can be implicitly converted to A*, and f has access to i in A
   }
   ```
   — *end example*]
 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
+name the private and protected members of 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 make the
+nominated friends members of the befriending class.
 [*Example 1*:
 The following example illustrates the differences between members and
 friends:
 }
 ```
 — *end example*]
+Declaring a class to be a friend implies that private and protected
+members of the class granting friendship can be named in the
+*base-specifier*s and member declarations of the befriended class.
 [*Example 2*:
 ``` cpp
 class A {
   class B { };
   friend class X;
 };
+struct X : A::B {               // OK, A::B accessible to friend
+  A::B mx;                      // OK, A::B accessible to member of friend
   class Y {
+    A::B my;                    // OK, A::B accessible to nested member of friend
   };
 };
 ```
 — *end example*]
 };
 ```
 — *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 can 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 4*:
 ``` cpp
 class C;
 typedef C Ct;
 class X1 {
+  friend C;                     // OK, class C is a friend
 };
 class X2 {
+  friend Ct;                    // OK, class C is a friend
+  friend D;                     // error: D not found
+  friend class D;               // OK, elaborated-type-specifier declares new class
 };
 template <typename T> class R {
   friend T;
 };
 R<C> rc;                        // class C is a friend of R<C>
+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]].
+[*Note 2*:
+A friend declaration refers to an entity, not (all overloads of) a name.
+A member function of a class `X` can be a friend of a class `Y`.
+[*Example 5*:
 ``` cpp
 class Y {
   friend char* X::foo(int);
   friend X::X(char);            // constructors can be friends
 };
 ```
 — *end example*]
+— *end note*]
+A function may be defined in a friend declaration of a class if and only
+if the class is a non-local class [[class.local]] and the function name
+is unqualified.
+[*Example 6*:
 ``` cpp
 class M {
   friend void f() { }           // definition of global f, a friend of M,
                                 // not the definition of a member function
 ```
 — *end example*]
 Such a function is implicitly an inline [[dcl.inline]] function if it is
+attached to the global module.
+[*Note 3*: If a friend function is defined outside a class, it is not
+in the scope of the class. — *end note*]
 No *storage-class-specifier* shall appear in the *decl-specifier-seq* of
 a friend declaration.
+A member nominated by a friend declaration shall be accessible in 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 7*:
 ``` cpp
 class A {
   friend class B;
   int a;
 };
 ```
 — *end example*]
+[*Note 4*: A friend declaration never binds any names
+[[dcl.meaning]], [[dcl.type.elab]]. — *end note*]
+[*Example 8*:
+``` cpp
+// Assume f and g have not yet been declared.
+void h(int);
+template <class T> void f2(T);
+namespace A {
+  class X {
+    friend void f(X);           // A::f(X) is a friend
+    class Y {
+      friend void g();          // A::g is a friend
+      friend void h(int);       // A::h is a friend
+                                // ::h not considered
+      friend void f2<>(int);    // ::f2<>(int) is a friend
+    };
+  };
+  // A::f, A::g and A::h are not visible here
+  X x;
+  void g() { f(x); }            // definition of A::g
+  void f(X) { ... }       // definition of A::f
+  void h(int) { ... }     // definition of A::h
+  // A::f, A::g and A::h are visible here and known to be friends
+}
+using A::x;
+void h() {
+  A::f(x);
+  A::X::f(x);                   // error: f is not a member of A::X
+  A::X::Y::g();                 // error: g is not a member of A::X::Y
+}
+```
+— *end example*]
 [*Example 9*:
 ``` cpp
 class X;
 ### 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 direct 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
 class B {
 void f() {
   D d;
   B* pb = &d;
   D* pd = &d;
+  pb->f();                      // OK, B::f() is public, D::f() is invoked
   pd->f();                      // error: D::f() is private
 }
 ```
 — *end example*]
 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 declaration can be reached by several paths through a multiple
+inheritance graph, the access is that of the path that gives most
+access.
 [*Example 1*:
 ``` cpp
 class W { public: void f(); };
 class E {
   int x;
   class B { };
   class I {
+    B b;                        // OK, E::I can access E::B
     int y;
     void f(E* p, int i) {
+      p->x = i;                 // OK, E::I can access E::x
     }
   };
   int g(I* p) {
     return p->y;                // error: I::y is private

Diff to HTML by rtfpessoa