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

Files changed (1) hide show

tmp/tmp4py43fyt/{from.md → to.md} +197 -75

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

@@ -16,29 +16,40 @@ 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.
 ``` cpp
 class X {
   int a;            // X::a is private by default
 };
 struct S {
   int a;            // S::a is public by default
 };
 ```
 Access control is applied uniformly to all names, whether the names are
-referred to from declarations or expressions. Access control applies to
-names nominated by `friend` declarations ([[class.friend]]) and
-*using-declaration*s ([[namespace.udecl]]). In the case of overloaded
-function names, access control is applied to the function selected by
-overload resolution. 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:
@@ -49,10 +60,12 @@ void f() {
   A::BB x;          // OK, typedef name A::BB is public
   A::B y;           // access error, A::B is private
 }
 ```
 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
@@ -61,13 +74,16 @@ 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*. this
-access also applies to implicit references to constructors, conversion
-functions, and destructors.
 ``` cpp
 class A {
   typedef int I;    // private member
   I f();
@@ -96,20 +112,24 @@ Here, all the uses of `A::I` are well-formed because `A::f`, `A::x`, and
 is as the return type of a member of class `A`. Similarly, the use of
 `A::B` as a *base-specifier* is well-formed because `D` is derived from
 `A`, so checking of *base-specifier*s must be deferred until the entire
 *base-specifier-list* has been seen.
 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*.
 ``` cpp
 class B { };
 template <class T> class C {
 protected:
   typedef T TT;
@@ -119,31 +139,39 @@ template <class U, class V = typename U::TT>
 class D : public U { };
 D <C<B> >* d;       // access error, C::TT is protected
 ```
 ## 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.
 ``` cpp
 class X {
   int a;            // X::a is private by default: class used
 public:
   int b;            // X::b is public
   int c;            // X::c is public
 };
 ```
 Any number of access specifiers is allowed and no particular order is
 required.
 ``` cpp
 struct S {
   int a;            // S::a is public by default: struct used
 protected:
   int b;            // S::b is protected
@@ -152,42 +180,52 @@ private:
 public:
   int d;            // S::d is public
 };
 ```
-The effect of access control on the order of allocation of data members
-is described in  [[class.mem]].
 When a member is redeclared within its class definition, the access
 specified at its redeclaration shall be the same as at its initial
 declaration.
 ``` cpp
 struct S {
   class A;
   enum E : int;
 private:
   class A { };        // error: cannot change access
   enum E: int { e0 }; // error: cannot change access
 };
 ```
-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.
 ``` cpp
 class A { };
 class B : private A { };
 class C : public B {
   A* p;             // error: injected-class-name A is inaccessible
   ::A* q;           // OK
 };
 ```
 ## 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
@@ -203,25 +241,31 @@ 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`.
 ``` cpp
-class B { /* ... */ };
-class D1 : private B { /* ... */ };
-class D2 : public B { /* ... */ };
-class D3 : B { /* ... */ }; // B private by default
-struct D4 : public B { /* ... */ };
-struct D5 : private B { /* ... */ };
-struct D6 : B { /* ... */ }; // B public by default
-class D7 : protected B { /* ... */ };
-struct D8 : protected B { /* ... */ };
 ```
 Here `B` is a public base of `D2`, `D4`, and `D6`, a private base of
 `D1`, `D3`, and `D5`, and a protected base of `D7` and `D8`.
 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
@@ -250,10 +294,12 @@ void DD::f() {
   ::B* bp2 = (::B*)this;        // OK with cast
   bp2->mi = 3;                  // OK: access through a pointer to B.
 }
 ```
 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
@@ -261,10 +307,12 @@ A base class `B` of `N` is *accessible* at *R*, if
   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*.
 ``` cpp
 class B {
 public:
   int m;
 };
@@ -273,71 +321,85 @@ class S: private B {
   friend class N;
 };
 class N: private S {
   void f() {
-    B* p = this;    // OK because class S satisfies the fourth condition
-                    // above: B is a base class of N accessible in f() because
-                    // B is an accessible base class of S and S is an accessible
                     // base class of N.
   }
 };
 ```
 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]]). 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`. 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. 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`). 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 or friend 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`.
   ``` cpp
   class B;
   class A {
   private:
     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
   }
   ```
-If a class member access operator, including an implicit “`this->`,” is
 used to access a non-static data member or non-static member function,
 the reference is ill-formed if the left operand (considered as a pointer
 in the “`.`” operator case) cannot be implicitly converted to a pointer
-to the naming class of the right operand. This requirement is in
-addition to the requirement that the member be accessible as named.
 ## 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. the
-following example illustrates the differences between members and
 friends:
 ``` cpp
 class X {
   int a;
@@ -354,14 +416,18 @@ void f() {
   friend_set(&obj,10);
   obj.member_set(10);
 }
 ```
 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.
 ``` cpp
 class A {
   class B { };
   friend class X;
 };
@@ -372,10 +438,14 @@ struct X : A::B {   // OK: A::B accessible to friend
     A::B my;                    // OK: A::B accessible to nested member of friend
   };
 };
 ```
 ``` cpp
 class X {
   enum { a=100 };
   friend class Y;
 };
@@ -387,32 +457,42 @@ class Y {
 class Z {
   int v[X::a];                  // error: X::a is private
 };
 ```
 A class shall not be defined in a friend declaration.
 ``` cpp
 class A {
   friend class B { };           // error: cannot define class in friend declaration
 };
 ```
 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 ';'
 ```
-A `friend` declaration may be the *declaration* in a
-*template-declaration* (Clause  [[temp]], [[temp.friend]]).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.
 ``` cpp
 class C;
 typedef C Ct;
@@ -432,41 +512,51 @@ template <typename T> class R {
 R<C> rc;                        // class C is a friend of R<C>
 R<int> Ri;                      // OK: "friend int;" is ignored
 ```
-A function first declared in a friend declaration has external linkage (
-[[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`.
 ``` cpp
 class Y {
   friend char* X::foo(int);
   friend X::X(char);            // constructors can be friends
   friend X::~X();               // destructors can be friends
 };
 ```
 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.
 ``` cpp
 class M {
   friend void f() { }           // definition of global f, a friend of M,
                                 // not the definition of a member function
 };
 ```
-Such a function is implicitly `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
@@ -475,10 +565,12 @@ 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.
 ``` cpp
 class A {
   friend class B;
   int a;
 };
@@ -487,33 +579,35 @@ class B {
   friend class C;
 };
 class C  {
   void f(A* p) {
-    p->a++;         // error: C is not a friend of A
-                    // despite being a friend of a friend
   }
 };
 class D : public B  {
   void f(A* p) {
-    p->a++;         // error: D is not a friend of A
-                    // despite being derived from a friend
   }
 };
 ```
 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.
 ``` cpp
 class X;
 void a();
 void f() {
   class Y;
@@ -529,10 +623,12 @@ void f() {
   X* px;            // OK, but ::X is found
   Z* pz;            // error, no Z is found
 }
 ```
 ## 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 (
@@ -542,10 +638,12 @@ 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`.
 ``` cpp
 class B {
 protected:
   int i;
   static int j;
@@ -561,15 +659,14 @@ class D2 : public B {
 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;                     // OK (because refers to static member)
   D2::j = 6;                    // OK (because refers to static member)
 }
 void D2::mem(B* pb, D1* p1) {
   pb->i = 1;                    // ill-formed
@@ -587,16 +684,20 @@ void g(B* pb, D1* p1, D2* p2) {
   p1->i = 2;                    // ill-formed
   p2->i = 3;                    // ill-formed
 }
 ```
 ## 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.
 ``` cpp
 class B {
 public:
   virtual int f();
 };
@@ -609,26 +710,29 @@ 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
 }
 ```
 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.
 ``` cpp
 class W { public: void f(); };
 class A : private virtual W { };
 class B : public virtual W { };
 class C : public A, public B {
@@ -637,17 +741,21 @@ class C : public A, public B {
 ```
 Since `W::f()` is available to `C::f()` along the public path through
 `B`, access is allowed.
 ## 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.
 ``` cpp
 class E {
   int x;
   class B { };
@@ -663,22 +771,27 @@ class E {
     return p->y;                // error: I::y is private
   }
 };
 ```
 <!-- Link reference definitions -->
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [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.init]: basic.md#basic.start.init
 [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
@@ -695,11 +808,10 @@ class E {
 [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.inhctor]: special.md#class.inhctor
 [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
@@ -712,10 +824,11 @@ class E {
 [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.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
@@ -723,22 +836,29 @@ class E {
 [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.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
 [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.general]: expr.md#expr.prim.general
 [expr.ref]: expr.md#expr.ref
 [expr.unary.op]: expr.md#expr.unary.op
 [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
@@ -748,12 +868,14 @@ class E {
 [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.friend]: temp.md#temp.friend
 [temp.inst]: temp.md#temp.inst
 [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.

 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 {
   int a;            // X::a is private by default
 };
 struct S {
   int a;            // S::a is public by default
 };
 ```
+— *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:
   A::BB x;          // OK, typedef name A::BB is public
   A::B y;           // access error, A::B is private
 }
 ```
+— *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
 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
 class A {
   typedef int I;    // private member
   I f();
 is as the return type of a member of class `A`. Similarly, the use of
 `A::B` as a *base-specifier* is well-formed because `D` is derived from
 `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:
   typedef T TT;
 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*:
 ``` cpp
 class X {
   int a;            // X::a is private by default: class used
 public:
   int b;            // X::b is public
   int c;            // X::c is public
 };
 ```
+— *end example*]
 Any number of access specifiers is allowed and no particular order is
 required.
+[*Example 2*:
 ``` cpp
 struct S {
   int a;            // S::a is public by default: struct used
 protected:
   int b;            // S::b is protected
 public:
   int d;            // S::d is 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.
+[*Example 3*:
 ``` cpp
 struct S {
   class A;
   enum E : int;
 private:
   class A { };        // error: cannot change access
   enum E: int { e0 }; // error: cannot change access
 };
 ```
+— *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*]
+[*Example 4*:
 ``` cpp
 class A { };
 class B : private A { };
 class C : public B {
   A* p;             // error: injected-class-name A is inaccessible
   ::A* q;           // OK
 };
 ```
+— *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
 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`.
+[*Example 1*:
 ``` cpp
+class B { ... };
+class D1 : private B { ... };
+class D2 : public B { ... };
+class D3 : B { ... }; // B private by default
+struct D4 : public B { ... };
+struct D5 : private B { ... };
+struct D6 : B { ... }; // B public by default
+class D7 : protected B { ... };
+struct D8 : protected B { ... };
 ```
 Here `B` is a public base of `D2`, `D4`, and `D6`, a private base of
 `D1`, `D3`, and `D5`, and a protected base of `D7` and `D8`.
+— *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.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
   ::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
   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*:
 ``` cpp
 class B {
 public:
   int m;
 };
   friend class N;
 };
 class N: private S {
   void f() {
+    B* p = this;    // OK because class S satisfies the fourth condition above: B is a base class of N
+                    // accessible in f() because B is an accessible base class of S and S is an accessible
                     // base class of N.
   }
 };
 ```
+— *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
+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*]
+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;
   class A {
   private:
     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*]
+If a class member access operator, including an implicit “`this->`”, is
 used to access a non-static data member or non-static member function,
 the reference is ill-formed if the left operand (considered as a pointer
 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
+make the nominated friends members of the befriending class.
+[*Example 1*:
+The following example illustrates the differences between members and
 friends:
 ``` cpp
 class X {
   int a;
   friend_set(&obj,10);
   obj.member_set(10);
 }
 ```
+— *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;
 };
     A::B my;                    // OK: A::B accessible to nested member of friend
   };
 };
 ```
+— *end example*]
+[*Example 3*:
 ``` cpp
 class X {
   enum { a=100 };
   friend class Y;
 };
 class Z {
   int v[X::a];                  // error: X::a is private
 };
 ```
+— *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* (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;
 typedef C Ct;
 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]]).
 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
   friend X::~X();               // destructors can be friends
 };
 ```
+— *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
 };
 ```
+— *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
 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;
 };
   friend class C;
 };
 class C  {
   void f(A* p) {
+    p->a++;         // error: C is not a friend of A despite being a friend of a friend
   }
 };
 class D : public B  {
   void f(A* p) {
+    p->a++;         // error: D is not a friend of A despite being derived from a friend
   }
 };
 ```
+— *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;
 void a();
 void f() {
   class Y;
   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 (
 [[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 {
 protected:
   int i;
   static int j;
 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
   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 {
 public:
   virtual int f();
 };
 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*]
 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*:
 ``` cpp
 class W { public: void f(); };
 class A : private virtual W { };
 class B : public virtual W { };
 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 {
   int x;
   class B { };
     return p->y;                // error: I::y is private
   }
 };
 ```
+— *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.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.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.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.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.

Diff to HTML by rtfpessoa