标签: enable-shared-from-this

我在shared_ptr和weak_ptr一起使用时遇到了麻烦enable_shared_from_this。

当我用Google搜索所见事物的症状时，每个人都建议“ shared_from_this()当没有shared_ptr实例拥有您的对象时，您将无法使用。

但这不是我的情况。

考虑以下代码：

#include <memory>
#include <cassert>

class MyClass : std::enable_shared_from_this<MyClass>
{
public:
    void this_fails()
    {
        // Doesn't even assert(), because it throws bad_weak_ptr
        assert(shared_from_this());
    }
    void this_fails_too()
    {
        std::weak_ptr<MyClass> weak = weak_from_this();
        std::shared_ptr<MyClass> strong = weak.lock();
        // This assert fails
        assert(strong.get());
    }
};

int main()
{
    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();

    obj->this_fails();
    obj->this_fails_too();
}

两种方法都会MyClass使程序崩溃。我一定缺少明显的东西-这是什么？

BI正在enable_shared_from_this我的代码中使用,我不确定它的用法是否正确.这是代码:

class A: public std::enable_shared_from_this<A>
{
public:
    void foo1()
    {
        auto ptr = shared_from_this(); 
    }
};

class B:public std::enable_shared_from_this<B>
{
public:
    void foo2()
    {
        auto ptr = shared_from_this(); 
    }
};

class C:public std::enable_shared_from_this<C>
{
public:
    void foo3()
    {
        auto ptr = shared_from_this(); 
    }
};

class D: public A, public B, public C
{
public:
    void foo()
    {
        auto ptr = A::shared_from_this(); 
    }
};

这些用法是否make_shared_from_this()正确,假设它们总是被shared_ptrD 调用？

我正在玩一些使用shared_ptr和enable_shared_from_this,而我遇到了一些我不太懂的东西.

在我的第一次尝试中,我构建了这样的东西:

class shared_test : std::enable_shared_from_this<shared_test> {
public:
    void print(bool recursive) {
        if (recursive) {
            shared_from_this()->print(false);
        }

        std::cout << "printing" << std::endl;
    }
};

请注意,此类私有地扩展std :: enable_shared_from_this.这显然有很大的不同,因为执行这样的事情:

int main() {
    auto t(std::make_shared<shared_test>());
    t->print(true);
    return 0;
}

抛出bad_weak_ptr异常.好像我从std :: enable_shared_from_this中将类定义更改为公开的,这就是find.

为什么,我在这里想念什么？并没有办法使它适用于私有继承,因为shared_test类的"外部世界"不需要知道它是否允许共享...(至少,如果你问我,还是我又想念一些东西？)

我在使用boost enable_shared_from_this和多重继承时遇到了一些麻烦.

该场景可以描述如下:

1. 类A实现了一些功能,应该继承enable_shared_from_this

2. 类B实现了另一个功能,应该继承enable_shared_from_this

3. 类D从A和B(class D : public A, public B {})继承功能

4. 当我B从类中使用一些类功能时,D我得到了一个异常(bad_weak_ptr)

5. 继承enable_shared_from_this课程D对我来说不是一个选择

我不知道如何解决这个问题.

哦,我正在使用Visual C++ 2010.

该enable_shared_from_this助手包含被创建共享指向对象时设置的弱指针.这意味着有一个引用计数(单独分配或与使用的对象一起分配make_shared)和一个额外weak_ptr的对象.

现在为什么不简单地包含引用计数呢？shared_ptr从哑指针设置时,必须完全定义类型,因此shared_ptr构造函数或赋值运算符可以检测从中派生的类型enable_shared_from_this并使用正确的计数器,并且格式可以保持不变,因此复制无关紧要.实际上,shared_ptr已经有必要检测它来设置嵌入式weak_ptr.

我有一个对象(Z),它来自另外两个对象(A和B).

A和B都从派生enable_shared_from_this<>分别enable_shared_from_this<A>和enable_shared_from_this<B>.

当然我打电话shared_from_this()给Z.当然编译器报告这个含糊不清.

我的问题是:

• 继承两次是安全的enable_shared_from_this<>还是会创建两个分开的引用计数(坏!)
• 如果不安全,我该如何解决？

注意:当基类和派生类都继承自boost :: enable_shared_from_this但我没有真正回答时,我发现这个其他问题是坏的弱指针.我virtual也应该使用这个技巧吗？

我的类继承自多个基类，其中之一是std::enable_shared_from_this. 必须是第一垒吗？

假设以下示例代码：

struct A { ~A(); };
struct B { ~B(); };
struct C : A, B, std::enable_shared_from_this<C> {};

std::make_shared<C>(); 

当~A()与~B()运行，我可以肯定的是，当存储C生活仍然存在？

鉴于此类是enable_shared_from_this:

class connection : public std::enable_shared_from_this<connection>
{
   //...
};

假设我创建的两个实例std::shared_ptr来自同一 connection*如下:

std::shared_ptr<connection> rc(new connection);

std::shared_ptr<connection> fc(rc.get(), [](connection const * c) {
                                   std::cout << "fake delete" << std::endl;
                               });

到目前为止它的好处,因为资源{ connection*}由一个单独 拥有shared_ptr- rc确切地说,并且fc只有一个假的删除器.

在那之后,我这样做:

auto sc = fc->shared_from_this();
//OR auto sc = rc->shared_from_this(); //does not make any difference!

现在哪个shared_ptr- rc或fc- 将sc 与其分享其引用计数？换一种说法,

std::cout << rc->use_count() << std::endl;
std::cout << fc->use_count() …

我正在学习智能指针和shared_from_this. 在类继承关系中，会很难理解。

我有两个基类CA和CB，它们派生自enable_shared_from_this，子类CC派生自CA和CB。我想从类自身中取出三个类的共享指针，所以我写了sharedCAfromThis,sharedCBfromThis和sharedCCfromthis。

class CA  : private enable_shared_from_this<CA> {
public:
    shared_ptr<CA> sharedCAfromThis() { return shared_from_this();  }
    virtual ~CA() {};
    void print() {
        cout << "CA" << endl;
    }
};

class CB : private enable_shared_from_this<CB> {
public:
    shared_ptr<CB> sharedCBfromThis() { return shared_from_this();  }
    virtual ~CB() {};
    void print() {
        cout << "CB" << endl;
    }
};

class CC : public CA, …

我有两个类A，B其中B是 的子类A。我需要两个类才能使用std::enable_shared_from_this。

我试过这个：

#include <memory>
#include <iostream>
#include <vector>


class A : public std::enable_shared_from_this<A> {
  public:
    void insertme(std::vector<std::shared_ptr<A>>& v) {
        std::cout << "A::insertme\n";
        v.push_back(shared_from_this());
        std::cout << "OK\n";
    }
};

class B : public A, public std::enable_shared_from_this<B> {
  public:
    void insertme(std::vector<std::shared_ptr<B>>& v) {
        std::cout << "B::insertme\n";
        v.push_back(std::enable_shared_from_this<B>::shared_from_this());
        std::cout << "OK\n";
    }
};

int main()
{
    std::vector<std::shared_ptr<A>> va;
    std::vector<std::shared_ptr<B>> vb;

    std::shared_ptr<A> pa = std::make_shared<A>();
    std::shared_ptr<B> pb = std::make_shared<B>();

    pa->insertme(va);
    pb->insertme(vb);
}

（为了避免 …