Why is this protected member not accessible from the derived class?

Question

I thought that protected members in a base class are accessible from a derived class, but not so:

template <typename T>
class SharedPointer
{
protected:
    explicit SharedPointer(T* const ptr) : ptr(ptr) {}

public:
    constexpr SharedPointer() : ptr(nullptr) { }

protected:
    T* ptr; 
};

template <typename T>
class WeakPointer : public SharedPointer<T>
{
protected:
    using parent_t = SharedPointer<T>;
    WeakPointer(T* ptr) : parent_t(ptr) {   }
public:
    WeakPointer(const WeakPointer& other)
    {
    }
    WeakPointer(WeakPointer&& other) = delete;
    WeakPointer(const SharedPointer<T>& other)
    {
        this->ptr = other.ptr;
    }    
};    

int main()
{
    SharedPointer<int> sp;
    WeakPointer<int> wp = sp;
}

The error I get is:

'SharedPointer<int>::ptr': cannot access protected member declared in class 'SharedPointer<int>'

What is the problem here?

Answer 1

Sometimes protected is not that intiutive. From Access specifiers on cppreference:

A protected member of a class is only accessible

1. to the members and friends of that class;
2. to the members of any derived class of that class, but only when the class of the object through which the protected member is accessed is that derived class or a derived class of that derived class:

And then follows an example.

In your case, 2) means that WeakPointer<T> can only acces ptr via a WeakPointer<T> object. If it could access ptr through a reference to a SharedPointer<T> then it could access ptr of a different derived class. And that's what the rules are made to avoid.

---

In this particular case, you do not actually need to access ptr in the derived class:

WeakPointer(const SharedPointer<T>& other) : SharedPointer<T>(other)
{}

Live Demo