Why does enable_shared_from_this crash if inheritance is not public instead of erroring out

Question

I was using shared_ptr in a project. And at one point I had to store the raw pointers as a void then later convert it back to its shared_ptr form in a callback where the void* was passed. But for some reason the code kept crashing. I didn't understand why since I wasn't getting any compiler errors or warnings. But I noticed that when I was inheriting from std::enable_shared_from_this I wasn't assigning it to be a public inheritance. And that's what was causing the crash.

I wrote an example code and I'm just wondering why it happens.

#include <memory>
#include <iostream>

class TestShared : public std::enable_shared_from_this<TestShared>{
private:
    int32_t id;
public:
    TestShared(int32_t id){
        this->id = id;
    }
    std::shared_ptr<TestShared> getshared(){
        return shared_from_this();
    }
    int32_t getid(){
        return id;
    }
};

int main(){
    std::shared_ptr<TestShared> ts(new TestShared(0xFF));
    void* tsp = ts.get();
    std::shared_ptr<TestShared> tsn = ((TestShared*)tsp)->getshared();
    std::cout << std::hex << tsn->getid();
    return 0;
}

So that code will execute and run fine and I get the expected result.

But when I remove public from the inheritance:

#include <memory>
#include <iostream>

class TestShared : std::enable_shared_from_this<TestShared>{
private:
    int32_t id;
public:
    TestShared(int32_t id){
        this->id = id;
    }
    std::shared_ptr<TestShared> getshared(){
        return shared_from_this();
    }
    int32_t getid(){
        return id;
    }
};

int main(){
    std::shared_ptr<TestShared> ts(new TestShared(0xFF));
    void* tsp = ts.get();
    std::shared_ptr<TestShared> tsn = ((TestShared*)tsp)->getshared();
    std::cout << std::hex << tsn->getid();
    return 0;
}

Then it results in a crash. So why does public make a difference here and why doesn't the compiler give a warning/error?

Answer 1

Being public is important because the shared_ptr system needs to access the enable_shared_from_this base class of the given type. And it can't do that if it's not publicly accessible from the given type.

There is no warning/error for a non-accessible base class because there is no way for the system to know that your code is wrong.

It is conceptually OK to use a shared_ptr constructor that can "enable shared_from_this" even if enable_shared_from_this is private. Why? Consider the following:

class B : public enable_shared_from_this<B> {...};

class D : private B {...};

Now, B expects to be able to do shared_from_this gymnastics. But D privately inherited from it. So D's relationship to B (and thus to B::shared_from_this) is private. Maybe D is using B in such a way that it doesn't trigger any of the shared_from_this usage.

So if D is not relying on B::shared_from_this, if B is just an implementation-detail of D, why is it an error if someone puts a D in a shared_ptr?

There is no test you can come up with which will not give rise to false positives like this. Therefore, if the enable_shared_from_this base class is not accessible, then shared_ptr constructors that could try to use it simply do not attempt to use it.

Answer 2

According to https://en.cppreference.com/w/cpp/memory/enable_shared_from_this

A common implementation for enable_shared_from_this is to hold a weak reference (such as std::weak_ptr) to this. The constructors of std::shared_ptr detect the presence of an unambiguous and accessible (since C++17) enable_shared_from_this base and assign the newly created std::shared_ptr to the internally stored weak reference if not already owned by a live std::shared_ptr (since C++17).

If the inheritance is public, then when ts is initialized, it "records" in the enable_shared_from_this base subobject that it is the owner of the TestShared object. When getshared is later called, the base subobject is consulted, and a new shared_ptr object is created that shares ownership with ts.

If the inheritance is not public, then when ts is initialized, it doesn't "know" that there is an enable_shared_from_this subobject that it needs to write to. Thus, when getshared is called, the enable_shared_from_this subobject doesn't contain any information about who currently owns the object. In C++17, this results in an exception; before C++17, the result is undefined.