Question

我有简单的基类和派生类，我希望它们都有shared_from_this()。

这个简单的解决方案：

class foo : public enable_shared_from_this<foo> {
    void foo_do_it()
    {
        cout<<"foo::do_it\n";
    }
public:
    virtual function<void()> get_callback()
    {
        return boost::bind(&foo::foo_do_it,shared_from_this());
    }
    virtual ~foo() {};
};

class bar1 : public foo , public enable_shared_from_this<bar1> {
    using enable_shared_from_this<bar1>::shared_from_this;
    void bar1_do_it()
    {
        cout<<"foo::do_it\n";
    }
public:
    virtual function<void()> get_callback()
    {
        return boost::bind(&bar1::bar1_do_it,shared_from_this());
    }
};

在以下代码中导致异常tr1::bad_weak_ptr：

shared_ptr<foo> ptr(shared_ptr<foo>(new bar1));
function<void()> f=ptr->get_callback();
f();

所以在“谷歌搜索”之后我找到了以下解决方案：

class bar2 : public foo {
    void bar2_do_it()
    {
        cout<<"foo::do_it\n";
    }
    shared_ptr<bar2> shared_from_this()
    {
        return boost::static_pointer_cast<bar2>(foo::shared_from_this());
    }
public:
    virtual function<void()> get_callback()
    {
        return boost::bind(&bar2::bar2_do_it,shared_from_this());
    }
};

现在它有效。

对于父母和孩子，enable_shared_from_this是否有更好，更方便，更正确的方法？

由于

Answer 1

通过在基类上定义以下内容，可以使OP解决方案更加方便。

protected:
    template <typename Derived>
    std::shared_ptr<Derived> shared_from_base()
    {
        return std::static_pointer_cast<Derived>(shared_from_this());
    }

Answer 2

抱歉，但没有。

问题在于shared_ptr<foo>和shared_ptr<bar1>是不同的类型。我不明白发生在幕后的一切，但我认为当构造函数返回并分配给shared_ptr<foo>时，内部weak_ptr<bar1>看到没有什么是指向它（因为只有shared_ptr<bar1>会增加计数器）并重置自己。当您在bar1::shared_from_this中致电get_callback时，您会收到异常，因为内部weak_ptr未指向任何内容。

基本上，enable_shared_from_this似乎只能从层次结构中的单个类透明地工作。如果您尝试implementing it manually，问题就会变得明显。

Answer 3

@evoskuil的一个类似的解决方案，它可以减少派生类中的样板文件，但是你想要实现一个shared_from_this()函数，在类中的使用点产生以下代码：

auto shared_from_this() {
    return shared_from(this);
}

这在课堂外使用'shim'函数。通过这样做，它还为那些界面无法修改但是派生自enable_shared_from_this的类提供了一种干净的方法。

auto shared_that = shared_from(that);

注意：此处使用auto作为返回类型将取决于编译器的年龄。

可以放在库标题中的Shim函数：

template <typename Base>
inline std::shared_ptr<Base>
shared_from_base(std::enable_shared_from_this<Base>* base) 
{
    return base->shared_from_this();
}
template <typename Base>
inline std::shared_ptr<const Base>
shared_from_base(std::enable_shared_from_this<Base> const* base) 
{
    return base->shared_from_this();
}
template <typename That>
inline std::shared_ptr<That>
shared_from(That* that) 
{
    return std::static_pointer_cast<That>(shared_from_base(that));
}

上述代码依赖于传递给shared_from(...)的类型在其祖先的某个点继承自std::enable_shared_from_this<Base>的事实。

调用shared_from_base将确定最终的类型。由于我们知道That继承自Base，因此可以进行静态向下转换。

可能存在一些具有类型转换运算符的类的病态极端情况..但是这不太可能发生在不打算破解它的代码中。

示例：

struct base : public std::enable_shared_from_this<base> {}; struct derived : public base { auto shared_from_this() { return shared_from(this); } // Can also provide a version for const: auto shared_from_this() const { return shared_from(this); } // Note that it is also possible to use shared_from(...) from // outside the class, e.g. // auto sp = shared_from(that); }; template <typename X> struct derived_x : public derived { auto shared_from_this() { return shared_from(this); } };

编译测试：

int main() { auto pbase = std::make_shared<base>(); auto pderived = std::make_shared<derived>(); auto pderived_x = std::make_shared<derived_x<int> >(); auto const& const_pderived = *pderived; const_pderived.shared_from_this(); std::shared_ptr<base> test1 = pbase->shared_from_this(); std::shared_ptr<derived> test2 = pderived->shared_from_this(); std::shared_ptr<derived_x<int> > test3 = pderived_x->shared_from_this(); return 0; }

A nice tutorial
我发布的
先前的解决方案，保持使评论仍然有意义 - 这将函数放在基类中，这有一些问题 - 尤其是'正常'所需的实现之间的不一致课程和模板课程另外，对于新的类层次结构，需要重复基类中的实现，这不是所有DRY。此外，基类函数通过从不同对象提供基类指针而遭受滥用的可能性。上面的新方案完全避免了这种情况，并且运行时断言（...）检查结束。

旧实施：

#include <cassert> #include <memory> class base : public std::enable_shared_from_this<base> { protected: template <typename T> std::shared_ptr<T> shared_from(T* derived) { assert(this == derived); return std::static_pointer_cast<T>(shared_from_this()); } }; class derived : public base { public: auto shared_from_this() { return shared_from(this); } }; template <typename X> class derived_x : public derived { public: auto shared_from_this() { return this->template shared_from(this); } }; int main() { auto pbase = std::make_shared<base>(); auto pderived = std::make_shared<derived>(); auto pderived_x = std::make_shared<derived_x<int> >(); std::shared_ptr<base> test1 = pbase->shared_from_this(); std::shared_ptr<derived> test2 = pderived->shared_from_this(); std::shared_ptr<derived_x<int> > test3 = pderived_x->shared_from_this(); return 0; }

如何enable_shared_from_this父和派生

3 个答案: