enable_shared_from_this for friend class

Question

I've got a class with a private ctor only constructible by friend classes using a create method:

class B {
    friend class A;
private:
    B(A* parent) { m_parent = parent; };

    A* m_parent;
};

class A {
public:
    A* createB() { return new B( this ); };
};

I want createB to instead return a shared_ptr to B. I'm currently solving it this way:

std::shared_ptr<B>
A::createB( A* parent )
{
    return std::shared_ptr<B>( new B( this ) );
}

But since there is std::enable_shared_from_this for inherited classes where my solution is declared as bad style I wanted to ask for a better solution.

Thanks.

As a side note, consider using `std::make_shared(this);` instead. — François Andrieux, Feb 17 '17 at 15:38
It's not clear to me where you intend to use `enable_shared_from_this` or what problem you are trying to solve with it. — François Andrieux, Feb 17 '17 at 15:40
I'm using this structure because I do some more things before creating an instance of B. enable_shared_from_this is for creating a shared_ptr to the current instance where the above style of creating a shared_ptr is declared as bad. I thought there would exist something similar for friend classes. — Zer0Knowledge, Feb 17 '17 at 15:44
I think you may misunderstand the purpose of `enable_shared_from_this`. It's purpose is to be derived from to provide `shared_from_this` which only exists to solve a specific problem. That problem is obtaining a copy of the `shared_ptr` for an instance *that already exists* and *that is already managed by a shared_ptr*. It serves no purpose in create a new instance of your class. Perhaps it would be useful if `B`'s constructor required a `shared_ptr` instead of `A*`. In that case, `A` might take advantage of `enable_shared_from_this`. I'll write up an answer if this is the case. — François Andrieux, Feb 17 '17 at 15:47
Okay, that would be useful to unstand it fully. A is a class instantiated only once giving the option of creating a lots of B's (with shared ownership). — Zer0Knowledge, Feb 17 '17 at 15:57

score 1 · Accepted Answer · edited May 23 '17 at 12:00

The only scenario that I can see where enable_shared_from_this might come into play in your example is if B::m_parent was of type std::shared_ptr<A> instead of A*.

#include <memory>
class B {
    friend class A;
private:
    B(std::shared_ptr<A> && parent) : m_parent(std::move(parent)) {}

    std::shared_ptr<A> m_parent;
};

In this case, createB must pass a shared_ptr<A> but you can't simply use shared_ptr<A>(this). This would cause this to be deleted when the shared_ptr was destroyed, but you didn't allocate this yourself. It's extremely improbable that this what you want to do. For example, if this is managed by an existing shared_ptr<A> then you will have two different shared_ptr<A> that don't know of each other, they will both eventually try to delete the same instance. Using enable_shared_from_this let's you get a copy of the actual shared_ptr<A> that manages this such that they are aware of each other (they share a reference counter).

class A : std::enable_shared_from_this<A> {
public:
    std::shared_ptr<B> createB() { 
        return std::shared_ptr<B>(new B(shared_from_this()));
    };
};

This can only work if there already exists a shared_ptr<A> to copy. For example, this would be a valid use of A::createB.

int main()
{
    auto my_A = std::make_shared<A>();
    auto my_B = my_A->createB();
    return 0;
}

This is not a valid use of A::createB. You will get an std::bad_weak_ptr exception.

int main()
{
    A my_A;
    auto my_B = my_A.createB();
    return 0;
}

Note that in the line return std::shared_ptr<B>(new B(shared_from_this())); I did not use std::make_shared<B> like I had suggested earlier. std::make_shared and non-public constructors are not compatible, you need a workaround that isn't part of your original question. See this question for more information on that.

enable_shared_from_this for friend class

1 Answers1