This code:

class Parent
{
protected:
    int protVar;
};


class Child : public Parent
{
private:
    void function(const Parent& ref);
};


void Child::function(const Parent& ref)
{
    int x = this->protVar;
    int y = ref.protVar;
} 

Gives an error: namely, that the last expression "ref.protVar" is invalid because protVar is protected. But I thought protected allowed Child classes to see it? Why is it protecting the other instance? As far as I knew, private and protected were on a per-class basis, not a per-instance basis. After all, you don''t have to use accessors when writing overloaded operators, for example. The fact that the operator is part of the class allows you to access private and protected members of another class of the same type. Is this therefore just an exception for classes of identical type to be able to see the protected members of other instances? My understanding must be wrong, since both GCC and MSVC tell me my code won''t work, but it seems very inconsistent... either protected should work on a per-class basis or a per-instance basis, and yet it seems to work per-class when it''s the same class and per-instance when it''s a derived one. Or to put it another way: ClassA instance 1 can access a private variable of ClassA instance 2, but can''t access ClassA instance 2''s protected variables it inherited from ClassA''s parent. Why? Can anyone correct my logic here? [ MSVC Fixes | STL | SDL | Game AI | Sockets | C++ Faq Lite | Boost | Asking Questions | Organising code files | My stuff ]

The Standard''s probably a good place to start:

quote:
protected; that is, its name can be used only be members and friends of the class in which it is declared, and by members and friends of classes derived from this class.

Which is in line with what you''ve said. Additionally, section 11.5 of the Standard gives:

quote:
When a friend or a member function of a derived class references a protected nonstatic member of a base class, an access check applies in addition to those described earlier in clause 11. Except when forming a pointer to member, the access must be through a pointer to, reference to, or object of the derived class itself (or any class derived from that class).

The emboldened text highlights the key-phrase in the paragraph which should clear up your confusion.

quote:Original post by Kylotan
Or to put it another way: ClassA instance 1 can access a private variable of ClassA instance 2, but can''t access ClassA instance 2''s protected variables it inherited from ClassA''s parent. Why?

It can. But you try to access members of the Parent class, not of the same class (Child).

This will work:

class Parent{protected:    int protVar;};class Child : public Parent{private:    void function(const Child& ref);};void Child::function(const Child& ref){    int x = this->protVar;    int y = ref.protVar;}  

The other possibility would be to declare Parent as a friend.

quote:Original post by Kylotan
Gives an error: namely, that the last expression "ref.protVar" is invalid because protVar is protected. But I thought protected allowed Child classes to see it? Why is it protecting the other instance? ...

Damn, and i thought moderators where pros !

quote:Original post by MadKeithV
To declare Child as friend in Parent you mean?

Yeah this question threw me at first, but I looked it up and tweaked it and realised that the Parent reference is not guaranteed to point to a Child, or even to a derived class of Parent that preserves the access rights (class Child2 : private Parent !! ), therefore cannot be allowed access to the protected member variable.

And you're right MadKeithV: it's absolutely not a secure way to do it. It's a quick but dirty way to resolve the problem.
this solution was only proposed for the example given, and only for it. It's trivial that the 'ref' MUST be a 'Parent' class when declaring it friend.

The other solution proposed by him is good (but maybe doesn't fit to the problem).

[edited by - misterX on September 3, 2002 8:29:42 AM]

Yeah, i''m very sorry, i''m the idiot !

quote:Original post by misterX
Damn, and i thought moderators where pros !

Hey, I think that's a little unfair! I know what protected means, but if you take the fact that you can inspect another instance's private variables, it would make sense that you can inspect another instance's protected variables when you derive from that class... after all, the implementation is already available to the current class.

Thanks for the clarification, Sabreman. I don't quite understand the motivation for the decision, but I'm sure it makes sense to someone who knows more than I do.

EDIT: Rewritten to say what I meant rather than something else entirely...

[ MSVC Fixes | STL | SDL | Game AI | Sockets | C++ Faq Lite | Boost | Asking Questions | Organising code files | My stuff ]

[edited by - Kylotan on September 3, 2002 8:37:33 AM]