ralphg@tekig4.UUCP (03/13/87)
What does the keyword 'protected' do? A cursory examination of 'The C++ Programming Language' list of keywords does not show this anywhere. It does, however, appear in our 1.1 source in several places. Forgive me if I sound like I've just returned from Mars, but I'm confused. Also, I have little more in the way of documentation other then what was distributed on tape. rtg
hansen@pegasus.UUCP (03/27/87)
< What does the keyword 'protected' do? A cursory examination of 'The C++
< Programming Language' list of keywords does not show this anywhere. It
< does, however, appear in our 1.1 source in several places. Forgive me if
< I sound like I've just returned from Mars, but I'm confused. Also, I have
< little more in the way of documentation other then what was distributed
< on tape.
I waited a couple of weeks for someone else to answer this, but I haven't
seen anything....
In the Release notes for C++ that come with the cfront translator, you will
find these paragraphs: (Copyright AT&T)
1. Release 1.1 Overview
1.1 C++ Language Extensions
The AT&T C++ Translator, Release 1.1, provides two extensions to the C++
language. First, "protected" class members, a new level of data-hiding, has
been added to facilitate the use of nested derived classes. Second, pointers
to class members are now allowed.
Two additional labels may now be declared within the class declaration,
those of "protected" and "private". Multiple label entries within a class
declaration are now allowed, permitting class members to be grouped by
functionality rather than by level of data visibility.
...
3.2 Protected Class Members
A new level of data-hiding, that of a "protected" class member, is now
provided. A "protected" member of a class B behaves like a public member of
B to member functions of a class derived from B, but like a private member
of B to other functions. One way to think of "protected" members is as
private members to which a user can gain access to by class derivation.
"protected" is intended as a mechanism when you create nests of derived
classes. Here the black-box view of a type supported by the notion of
"private" is often inconveniently restrictive whereas the complete lack of
protection implied by "public" is an inviation to chaos. "Protected" is an
alternative to using friends or to having members with comments like
/* don't use this member unless you absolutely have to */
For example:
class BASE {
int a; // private
protected:
int b;
public:
int c;
void bf();
};
void BASE::bf()
{
a = 1; // ok
b = 2; // ok
c = 3; // ok
}
class DERIVED : public BASE {
// ...
void df();
};
void DERIVED::df()
{
a = 1; // error: a is private
b = 2; // ok: b is a protected member (of derived's base class)
c = 3; // ok
};
void f(BASE arg)
{
arg.a = 1; // error: a is private
arb.b = 2; // error: b is protected
arg.c = 3; // ok
};
Declaring a member "protected" indicates that the member is to be used by a
derived class. A derived class inherits access to protected members of a
public or private base class. A protected member of a public base class is
considered a protected member of the derived class. A protected member of a
private base class is considered a private member of the derived class. For
example, continuing with the example above:
class D2 : DERIVED { // note: derived is a PRIVATE base
void d2f();
};
void D2::d2f() {
a = 1; // error: a is private (to BASE)
b = 2; // ok: b is a protected member
c = 3; // ok
}
void D3::d3f() {
a = 1; // error: a is private (to BASE)
b = 2; // error: b is a protected member
// (not a protected member of a public base class)
c = 3; // error: c is from a private base class
}
Friends of a derived class can access protected members of the base class:
class BASE {
friend void ff(BASE arg);
int a; // private
protected:
int b;
public:
int c;
// ...
void bf();
};
void ff(BASE arg)
{
arg.a = 1; // ok: ff is a friend
arg.b = 2; // ok: ff is a friend
arg.c = 3; // ok
}
In addition to the labels "public" and "protected" a class may contain
"private" labels:
struct S {
int a; // public (since S is a struct)
private:
int b; // private
};
A class declaration can contain any number of labelled sections:
class S {
// data
protected:
// data
public:
// data
private:
// functions
protected:
// functions
public:
// functions
};
Note that "public" remains the only accepted base class label. That is, one
cannot declare a base class either "private" or "protected".
Tony Hansen
ihnp4!pegasus!hansen