[class.access] (original) (raw)

11 Classes [class]

11.8 Member access control [class.access]

11.8.1 General [class.access.general]

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.96

Members of a class defined with the keywordclassare private by default.

Members of a class defined with the keywordsstruct or unionare public by default.

[Example 1: class X { int a; };struct S { int a; }; — _end example_]

Access control is applied uniformly to declarations and expressions.

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: struct S { void f(int);private: void f(double);};void g(S* sp) { sp->f(2); } — _end example_]

[Note 3:

Because access control applies to the declarations named, if access control is applied to atypedef-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.

[Example 3: class A { class B { };public: typedef B BB;};void f() { A::BB x; A::B y; } — _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_]

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 4: class A { typedef int I; 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 { };struct D: A::B, A { };

Here, all the uses ofA​::​Iare well-formed becauseA​::​f,A​::​x, and A​::​Qare members of classAandgand R are friends of classA.

This implies, for example, that access checking on the first use ofA​::​Imust be deferred until it is determined that this use ofA​::​Iis as the return type of a member of classA.

Similarly, the use of A​::​B as abase-specifier is well-formed because Dis derived from 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 5: class B { };template <class T> class C { protected: typedef T TT;};template <class U, class V = typename U::TT> class D : public U { }; D <C<B> >* d; — _end example_]

11.8.2 Access specifiers [class.access.spec]

Anaccess-specifierspecifies the access rules for members following it until the end of the class or until anotheraccess-specifieris encountered.

[Example 1: class X { int a; public: int b; int c; }; — _end example_]

Any number of access specifiers is allowed and no particular order is required.

[Example 2: struct S { int a; protected: int b; private: int c; public: int d; }; — _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: struct S { class A;enum E : int;private: class A { }; enum E: int { e0 }; }; — _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_]

[Example 4: class A { };class B : private A { };class C : public B { A* p; ::A* q; }; — _end example_]

11.8.3 Accessibility of base classes and base class members [class.access.base]

If a class is declared to be a base class ([class.derived]) for another class using thepublicaccess 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 theprotectedaccess 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 theprivateaccess specifier, the public and protected members of the base class are accessible as private members of the derived class.97

In the absence of anaccess-specifierfor a base class,publicis assumed when the derived class is defined with the class-key structandprivateis assumed when the class is defined with the class-key class.

[Example 1: class B { };class D1 : private B { };class D2 : public B { };class D3 : B { }; struct D4 : public B { };struct D5 : private B { };struct D6 : B { }; class D7 : protected B { };struct D8 : protected B { };

HereBis a public base ofD2,D4, andD6, a private base ofD1,D3, andD5, and a protected base ofD7andD8.

— _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.

[Example 2: class B { public: int mi; static int si; };class D : private B { };class DD : public D { void f();};void DD::f() { mi = 3; si = 3; ::B b; b.mi = 3; b.si = 3; ::B::si = 3; ::B* bp1 = this; ::B* bp2 = (::B*)this; bp2->mi = 3; } — _end example_]

— _end note_]

A base classBofNisaccessibleat_R_, if

[Example 3: class B { public: int m;};class S: private B { friend class N;};class N: private S { void f() { B* p = this; } }; — _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 classXcan implicitly convert anX*to a pointer to a private or protected immediate base class ofX.

— _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 aqualified-idis 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 aqualified-idare used to name the member (as inp->T​::​m), the class naming the member is the class denoted by thenested-name-specifierof thequalified-id(that is,T).

— _end note_]

A membermis accessible at the point_R_when named in classNif

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_]

11.8.4 Friends [class.friend]

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: class X { int a;friend void friend_set(X*, int);public: void member_set(int);};void friend_set(X* p, int i) { p->a = i; } void X::member_set(int i) { a = i; } void f() { X obj; friend_set(&obj,10); obj.member_set(10);}

— _end example_]

Declaring a class to be a friend implies that private and protected members of the class granting friendship can be named in thebase-specifiers and member declarations of the befriended class.

[Example 2: class A { class B { };friend class X;};struct X : A::B { A::B mx; class Y { A::B my; };}; — _end example_]

[Example 3: class X { enum { a=100 };friend class Y;};class Y { int v[X::a]; };class Z { int v[X::a]; }; — _end example_]

If a friend-type-specifier in a friend declaration designates a (possibly cv-qualified) class type, that class is declared as a friend; otherwise, thefriend-type-specifier is ignored.

[Example 4: class C;typedef C Ct;class E;class X1 { friend C; };class X2 { friend Ct; friend D; friend class D; };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; R<C, E> rce; R<int> Ri; struct E { struct Nested; }; R<R<E>, R<C, int>> rr; — _end example_]

[Note 2:

A friend declaration refers to an entity, not (all overloads of) a name.

A member function of a classXcan be a friend of a classY.

[Example 5: class Y { friend char* X::foo(int);friend X::X(char); friend X::~X(); }; — _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: class M { friend void f() { } }; — _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_]

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 classmember-specification.

Friendship is neither inherited nor transitive.

[Example 7: class A { friend class B;int a;};class B { friend class C;};class C { void f(A* p) { p->a++; } };class D : public B { void f(A* p) { p->a++; } }; — _end example_]

[Example 8: void h(int);template <class T> void f2(T);namespace A { class X { friend void f(X); class Y { friend void g(); friend void h(int); friend void f2<>(int); };}; X x;void g() { f(x); } void f(X) { } void h(int) { } } using A::x;void h() { A::f(x); A::X::f(x); A::X::Y::g(); } — _end example_]

[Example 9: class X;void a();void f() { class Y;extern void b();class A { friend class X; friend class Y; friend class Z; friend void a(); friend void b(); friend void c(); }; X* px; Z* pz; } — _end example_]

11.8.5 Protected member access [class.protected]

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]).98

As described earlier, access to a protected member is granted because the reference occurs in a friend or direct member of some class C.

All other accesses involve a (possibly implicit) object expression ([expr.ref]).

In this case, the class of the object expression shall beC or a class derived from C.

[Example 1: class B { protected: int i;static int j;};class D1 : public B { };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; p1->i = 2; p2->i = 3; p2->B::i = 4; int B::* pmi_B = &B::i; int B::* pmi_B2 = &D2::i; B::j = 5; D2::j = 6; } void D2::mem(B* pb, D1* p1) { pb->i = 1; p1->i = 2; i = 3; B::i = 4; int B::* pmi_B = &B::i; int B::* pmi_B2 = &D2::i; j = 5; B::j = 6; } void g(B* pb, D1* p1, D2* p2) { pb->i = 1; p1->i = 2; p2->i = 3; } — _end example_]

11.8.6 Access to virtual functions [class.access.virt]

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: class B { public: virtual int f();};class D : public B { private: int f();};void f() { D d; B* pb = &d; D* pd = &d; pb->f(); pd->f(); } — _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 (Din the example above) is in general not known.

11.8.7 Multiple access [class.paths]

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: class W { public: void f(); };class A : private virtual W { };class B : public virtual W { };class C : public A, public B { void f() { W::f(); } };

SinceW​::​f()is available toC​::​f()along the public path throughB, access is allowed.

— _end example_]

11.8.8 Nested classes [class.access.nest]

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: class E { int x;class B { };class I { B b; int y;void f(E* p, int i) { p->x = i; } };int g(I* p) { return p->y; } }; — _end example_]