Error when casting derived class to protected base interface in std::make_shared

Question

I have this code:

#include <memory>

class SomeInterface {
public:
    virtual void VirtualMethod() {}

    virtual void PureVirtualMethod() = 0;
};

class SomeInterfaceDependent {
public:
    explicit SomeInterfaceDependent(SomeInterface* a) : a_(a) {}

private:
    SomeInterface* const a_;
};

class Implementation : protected SomeInterface {
public:
    void Init() {
        // Ok
        auto raw = new SomeInterfaceDependent(this);

        // Cannot cast 'Implementation' to its protected base class 'SomeInterface'.
        auto shared = std::make_shared<SomeInterfaceDependent>(this);

        // Ok
        SomeInterface* casted_some_interface = this;
        auto shared2 = std::make_shared<SomeInterfaceDependent>(casted_some_interface);
    }

protected:
    void PureVirtualMethod() override {}
};


int main() {
    Implementation i;
    i.Init();

    return 0;
}

C++ standard 17, compiler GCC.

I get error error: ‘SomeInterface’ is an inaccessible base of ‘Implementation’ when (and):

• SomeInterface inherited with protected access modifier.
• SomeInterfaceDependent created using std::make_shared.
• SomeInterface casted implicitly.

Why? Is it the std::make_shared bug?

Answer 1

Is it the std::make_shared bug?

No.

Why?

std::make_shared is not a friend of Implementation, and therefore it doesn't have access to its non-public bases, and therefore it cannot implicitly convert the pointer.

Answer 2

protected inheritance is NOT public to external classes.

Because of this, the compiler does not have visibility to see that Implementation inherits from SomeInterface, and will say its cannot do the cast.