Re: discussion of protected in Lippman
t <tmt513@Yahoo.com> wrote in news:1190359124.424889.152280@v29g2000prd.googlegroups.com:
Nevermind. I just tried it (which I should have done before
posting). Lippman is correct.
I was confusing:
(1) how a derived class inherits all the members of the base class and
can use the public and protected members, yet cannot use the inherited
private members; in particular, an inherited protected member becomes
a member of the derived class itself;
I think you may be putting too much importance on the whole inheritance thing. Inheritance just
provides access to a different interface to the parent object than just using the object does.
Fundamentally,
class Base {
public:
int a;
protected:
int b;
private:
int c;
};
class A {
private:
Base b;
};
can have the same memory layout as:
class B : private Base {
};
The difference between the two is the interface. (I've chosen private inheritance here so we can ignore
for the moment the inheritance of interface, since that is not where this question seems to lie.) In
the first example, you have access to the public interface of the base class, thus you can only use
'a'. In the second case, you have access to 'a' and 'b'. Neither class A nor class B have access to
'c' which the implementor of Base kept private for class Base's use only.
Where I am going with this is that both class A and class B are users of an interface to class Base.
It's a subtle attitude difference from the idea that inheriting from class Base somehow folds in all of
its members into you, but then removes access to the private members.
and
(2) if a derived class object has access to a base class object (this
doesn't include the base class PART of a derived class object), then
it can only access the base class object's public members and not its
protected or private members.
===
Is this correct? This was a bit too subtle for me to catch at first.
Well the point is that while a Derived object gets a special interface to the Base object from which it
is built. It doesn't, however, get any special rights to any other use of a Base object. So, using
the language from above, you get access to the inherited interface for the Base object if you are
accessing an object your same type, otherwise you get the public interface to the Base object.
If we add another couple classes to the above example:
class C : public Base {
};
class D : public Base {
};
Then we postualate some member functions:
// We only have access to the publics of b because b isn't a 'C'
void C::f(Base &b) {
b.a = 5; //ok, part of Bases publics
b.b = 5; // Bzzzt, Base protected member not available to C
b.c = 5; // Bzzzt, private
}
// We have access to the inherited interface because b is a 'C'
void C:f(C & c) {
c.a = 5; //ok, part of Base's publics, therefore part of C's publics
c.b = 5; // ok, Base protected member of C is available to C
c.c = 5; // Bzzzt, part of Bases privates
}
// We only have the publics because c isn't a 'C' either
void C:f(D & d) {
d.a = 5; //ok
d.b = 5; // Bzzt, Base protected member of D is not available to C
d.c = 5; // Bzzzt, Base private
}
The idea to be conveyed here is that just because class B has a special interface to its class Base,
that doesn't mean it has that same special interface to any other class Base it may encounter.
I see that I have blathered on quite a bit. Hopefully that helps some. In C++ there are often lots of
special cases, but generally they make some sort of sense and hopefully I haven't confused the issue
too much.
joe