http://stackoverflow.com/questions/16785069/why-cant-a-derived-class-call-protected-member-function-in-this-code

이거 왜 안 되는거임? 영어 잘 이해가 안 가서...


#include <iostream> class Base { protected: void somethingProtected() { std::cout << "lala" << std::endl; } }; class Derived : public Base { public: void somethingDerived() { Base b; b.somethingProtected(); // This does not compile somethingProtected(); // But this is fine } }; int main() { Derived d; d.somethingDerived(); return 0; }

I thought that maybe only the protected members of this can be used and protected members of other instances are forever unreachable.

But:

class Derived : public Base { public: void somethingDerived(Derived& d) { d.somethingProtected(); // This compiles even though d is // potentially a different instance } void somethingDerived(Base& b) { b.somethingProtected(); // This does not } };

I feel kind of nauseated by this, since I have been programming in C++ for some time, but I could not find any explanation for this behaviour.

EDIT:

It doesn't matter if it is the same or a different instance:

int main() { Derived d1, d2; // Two different instances d1.somethingDerived(d2); // This compiles fine d1.somethingDerived(d1); // This compiles fine return 0; }

EDIT2:

It seems that when it comes to access rights, it doesn't matter at all what instance of a class is being used:

class Base { public: void something(Base& b) // Another instance { ++b.a; // But can enter private members } private: int a; };


Even though access control in C++ works on per-class basis (as opposed to per-instance basis), protected access specifier has some peculiarities.

The language specification wants to ensure that you are accessing a protected member of some base subobject that belongs to the derived class. You are not supposed to be able access protected members of some unrelated independent objects of base type. In particular, you cannot access protected members of freestanding objects of base type. You are only allowed to access protected members of base objects that are embedded into derived objects as base subobjects.

For this reason, you have to access protected members through pointer->member syntax, reference.member or object.member syntax, where the pointer/reference/object refers to the derivedclass.

This means that in your example, protected member somethingProtected() is not accessible throughBase objects, Base * pointers or Base & references, but it is accessible through Derived objects, Derived * pointers and Derived & references. Your plain somethingProtected() access is allowed, since it is just a shorthand for this->somethingProtected() where this is of type Derived *.

b.somethingProtected() violates the above requirements.

Note that in accordance with the above rules in

void Derived::somethingDerived() { Base *b = this; b->somethingProtected(); // ERROR this->somethingProtected(); // OK }

the first call will also fail while the second one will compile, even though both are trying to access the same entity.


현상이은 해석이 되는 거 같기도 한데.. 

답글에서 어쩌구 저쩌구 이해가 잘 안감... 영어 좆망...


그러니까... derived클래스에서 Base*나 Base&를 이용한 protected멤버로의 접근은  

불가능하고... 으헝...