SC22/WG21/N1179
J16/99-0002
23 February, 1999
Thomas R Wilcox
trw@rational.com

• 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, and by members and friends of classes derived from this class (see class.protected).
• public; that is, its name can be used anywhere without access restriction.
• base private; that is, a private member of a base class. Its name can be used only by members and friends of the base class in which it is declared.

This wording takes the widely held position that all members of a base class are members of the derived class as well. The revised first paragraph of clause 11 now neatly partitions the set of class members into four, non-overlapping categories related to accessibility.

The next change is to paragraph 1 of clause 11.2. We must elide the four "accessible as" qualifications in this paragraph and just use the accessibility categories defined at the beginning of the clause. We can't use the term "accessible as" here since it really hasn't been defined yet. In fact, we aren't going to define it until paragraph 4. Also, if we add a last sentence to the paragraph to define what happens to private and base private members in the derived class, we make the semantics of the base-class access specifier complete and obviate the need for the rather vague and probably incorrect footnote that is there now. (This resolves issue 17).

Paragraphs 2 and 3 remain unchanged.

Paragraph 4 is where the circular definition of accessible base class and access to base class members is presented. We remove the circularity by first defining accessible base class in terms of the access categories defined at the beginning of the clause. And then define accessibility to base class member in terms of accessible base class.

After these changes, clause 11.2 reads as follows...

11.2 - Accessibility of base classes and base class members [class.access.base]

-1- If a class is declared to be a base class (clause class.derived) for another class using the public access specifier, the public members of the base class are accessible as public members of the derived class and protected members of the base class are accessible as protected members of the derived class. If a class is declared to be a base class for another class using the protected access specifier, the public and protected members of the base class are accessible as protected members of the derived class. If a class is declared to be a base class for another class using the private access specifier, the public and protected members of the base class are accessible as private members of the derived class*. In all cases, the private and base private members of the base class are base private members of the derived class regardless of the access specifier used to declare the base class.

-2- In the absence of an access-specifier for a base class, public is assumed when the derived class is declared struct and private is assumed when the class is declared class. [Example:

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]

-3- [Note: A member of a private base class might be inaccessible as an inherited member name, but accessible directly. Because of the rules on pointer conversions (conv.ptr) and explicit casts (expr.cast), a conversion from a pointer to a derived class to a pointer to an inaccessible base class might be ill-formed if an implicit conversion is used, but well-formed if an explicit cast is used. For example,

class B {
public:
	int mi;                 //  nonstatic member
	static int si;          //  static member
};
class D : private B {
};
class DD : public D {
	void f();
};
void DD::f() {
	mi = 3;                 //  error:  mi  is private in  D
	si = 3;                 //  error:  si  is private in  D
	B  b;
	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]

-4- A base class B of N is accessible at R, if

class B {
public:
  int m;
};
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 S accessible in f because f is a friend of S and m is private in S
                   // and S is a base class of N accessible in f because f is a member of N and a public
                   // member of S would be private in N.
  }
};

-5- A base class is said to be accessible if an invented public member of the base class is accessible. 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: 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. [Note: 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 named by the nested-name-specifier of the qualified-id (that is, T). If the member m is accessible when named in the naming class according to the rules below, the access to m is nonetheless ill-formed if the type of p cannot be implicitly converted to type T (for example, if T is an inaccessible base class of p's class). ]

 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 the reference R occurs in a member or friend of class N, or
• m as a member of N is protected, and the reference 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 private or protected, or
• there exists a base class B of N that is accessible at the point of reference R, and m is accessible at R when named in class B. [Example:

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 cast to  A*,
				//  and  f  has access to  i  in  A
}

Issue 9 Example:
    class D;
 
    class B
    {
     protected:
       int b1;
 
       friend void foo( D* pd );
    };
 
    class D : protected B { };
 
    void foo( D* pd )
    {
       if ( pd->b1 > 0 ); // Is 'b1' accessible?
    }

  class D;
 
  class B {
  private:
      int i;
      friend class D;
  };
 
  class C : private B { };
 
  class D : private C {
      void f() {
          B::i; //1: well-formed?
          i;    //2: well-formed?
      }
  };