Why can't a derived class call protected member function in this code?

Question

#include 

class Base
{  
protected:
    void somethingProtected()
    {
        std::cout << \"lala\" << std::endl;
    }
};

class Deri         


        

Answer 1

The Derived class can only access the protected base member in Derived objects. It cannot access the member in objects that are not (necessarily) Derived objects. In the cases that fail, you are trying to access the member via a Base &, and since this might refer to an object that is not Derived, the access can't be made.

Answer 2

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 derived class.

This means that in your example, protected member somethingProtected() is not accessible through Base 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.

Answer 3

I believe you have some confusion on how to access base class members. It is only this way:

class Derived : public Base
void drivedMethod() {
    Base::baseMethod();
}

in your example you are trying to access a protected member of another instance.

a Derived instance will have access to it's own protected members but not to another class instance protected members, this is by design.

In fact accessing the protected members of another class, from another instance members or from the main function are in fact both under public access...

http://www.cplusplus.com/doc/tutorial/inheritance/ (look for the access specifier table to see the different levels)

Both examples prove the same thing for example:

void somethingDerived(Base& b)
    {
        b.somethingProtected();  // This does not

here your Derived class is getting b as a parameter, so it is getting another instance of base, then because b.somethingProtected is not public it will not complie..

this will complie:

void somethingDerived()
{
   Base::somethingDerived();

your second example complies fine because you are accessing a public method on another d class

>  void somethingDerived(Base& b)
>     {
>         b.somethingProtected();  // This does not
>     }

Answer 4

What you have done is illegal in C++. A protected member can not be accessed by an object of a class. Only member functions can access protected members. protected members behave just like private members except while inherited by a derived class. Consider the program given below to understand the difference between private, public and protected members.

class Base
{
    private:
    void somethingPrivate()
    {
        std::cout << "sasa" << std::endl;
    }
    public:
    void somethingPublic()
    {
        std::cout << "haha" << std::endl;
    }
    protected:
    void somethingProtected()
    {
        std::cout << "lala" << std::endl;
    }
};

class Derived : public Base
{
public:
    void somethingDerived()
    {
       Base b;
       b.somethingPublic();   // Works fine.
       somethingProtected();  // This is also fine because accessed by member function.
       //b.somethingProtected();  // Error. Called using object b.
       //somethingPrivate();      // Error. The function is not inherited by Derived.
    }
};