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

Files changed (1) hide show

tmp/tmphattzasp/{from.md → to.md} +60 -46

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

@@ -14,13 +14,13 @@ A member of a class can be
 [*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.
 [*Example 1*:
@@ -63,14 +63,15 @@ void g(S* sp) {
 — *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:
@@ -81,10 +82,12 @@ 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*]
@@ -100,26 +103,26 @@ 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();
-  friend I g(I);
   static I x;
   template<int> struct Q;
   template<int> friend struct R;
 protected:
     struct B { };
 };
-A::I A::f() { return 0; }
-A::I g(A::I p = A::x);
 A::I g(A::I p) { return 0; }
 A::I A::x = 0;
 template<A::I> struct A::Q { };
 template<A::I> struct R { };
@@ -144,11 +147,11 @@ 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:
@@ -255,11 +258,11 @@ 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`.
@@ -289,11 +292,13 @@ 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
@@ -316,10 +321,12 @@ void DD::f() {
   ::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
@@ -329,11 +336,11 @@ A base class `B` of `N` is *accessible* at *R*, if
   `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*:
 ``` cpp
 class B {
 public:
   int m;
@@ -360,33 +367,39 @@ derived class to a pointer to that base class
 [*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
-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 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;
   class A {
   private:
     int i;
@@ -402,14 +415,14 @@ A member `m` is accessible at the point *R* when named in class `N` if
 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
 name the private and protected members of the class. A class specifies
@@ -481,31 +494,26 @@ class Z {
 };
 ```
 — *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
 };
@@ -513,24 +521,30 @@ 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`.
@@ -671,12 +685,12 @@ 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 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`.
@@ -703,14 +717,14 @@ class D2 : public B {
 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

 [*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.[^9]
+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*:
 — *end example*]
 [*Note 3*:
 Because access control applies to the declarations named, if access
+control is applied to a type alias, only the accessibility of the
 typedef or alias declaration itself is considered. The accessibility of
+the underlying entity is not considered.
+[*Example 3*:
 ``` cpp
 class A {
   class B { };
 public:
   A::BB x;          // OK, typedef A::BB is public
   A::B y;           // access error, A::B is private
 }
 ```
+— *end example*]
 — *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*]
 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 4*:
 ``` cpp
 class A {
   typedef int I;    // private member
+  I f() pre(A::x > 0);
+  friend I g(I) post(A::x <= 0);
   static I x;
   template<int> struct Q;
   template<int> friend struct R;
 protected:
     struct B { };
 };
+A::I A::f() pre(A::x > 0) { return 0; }
+A::I g(A::I p = A::x) post(A::x <= 0);
 A::I g(A::I p) { return 0; }
 A::I A::x = 0;
 template<A::I> struct A::Q { };
 template<A::I> struct R { };
 [[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 5*:
 ``` cpp
 class B { };
 template <class T> class C {
 protected:
 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.[^10]
 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`.
 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.
+[*Example 2*:
 ``` cpp
 class B {
 public:
   int mi;                       // non-static member
   ::B* bp2 = (::B*)this;        // OK with cast
   bp2->mi = 3;                  // OK, access through a pointer to B.
 }
 ```
+— *end example*]
 — *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
   `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 3*:
 ``` cpp
 class B {
 public:
   int m;
 [*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*]
+An expression E that designates a member `m` has a *designating class*
+that affects the access to `m`. This designating class is either
+- the innermost class of which `m` is directly a member if E is a
+  *splice-expression* or
+- the class in whose scope name lookup performed a search that found `m`
+  otherwise.
 [*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 designating the
+member is the class designated by the *nested-name-specifier* of the
 *qualified-id* (that is, `T`). — *end note*]
+A member `m` is accessible at the point *R* when designated in class `N`
+if
+- `m` is designated by a *splice-expression*, or
 - `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 designated in class `B`.
+  \[*Example 4*:
   ``` cpp
   class B;
   class A {
   private:
     int i;
 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 designating class of the right operand.
 [*Note 4*: This requirement is in addition to the requirement that the
+member be accessible as designated. — *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
 };
 ```
 — *end example*]
+A friend declaration that does not declare a function shall be a
+*friend-type-declaration*.
 [*Note 1*: A friend declaration can be the *declaration* in a
 *template-declaration* [[temp.pre]], [[temp.friend]]. — *end note*]
+If a *friend-type-specifier* in a friend declaration designates a
+(possibly cv-qualified) class type, that class is declared as a friend;
+otherwise, the *friend-type-specifier* is ignored.
 [*Example 4*:
 ``` cpp
 class C;
 typedef C Ct;
+class E;
 class X1 {
   friend C;                     // OK, class C is a friend
 };
   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 ... Ts> class R {
+  friend Ts...;
+};
+template <class... Ts, class... Us>
+class R<R<Ts...>, R<Us...>> {
+  friend Ts::Nested..., Us...;
 };
 R<C> rc;                        // class C is a friend of R<C>
+R<C, E> rce; // classes C and E are friends of R<C, E>
+R<int> Ri;                      // OK, ``friend int;'' is ignored
+struct E { struct Nested; };
+R<R<E>, R<C, int>> rr;          // E::Nested and C are friends of R<R<E>, R<C, int>>
 ```
 — *end example*]
 [*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`.
 ### 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 designating class
+[[class.access.base]].[^11]
 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`.
 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 designating 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 designating class B
   D2::j = 6;                    // OK (because refers to static member)
 }
 void D2::mem(B* pb, D1* p1) {
   pb->i = 1;                    // error

Diff to HTML by rtfpessoa