Question

我想将对象的引用存储为weak_ptr。在纯C ++中，以下工作：

#include <iostream>

#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

using namespace std;
using namespace boost;

struct Empty
{
    Empty(){}
};

struct Store
{
    weak_ptr<Empty> value;
    Store(){};

    void setValue(shared_ptr<Empty> v) {
        cout << "storing " << v << endl;
        this->value = weak_ptr<Empty>(v);
        shared_ptr<Empty> v_ok = this->value.lock();
        if (v_ok) {
            cout << "ok, v has been stored" << endl;
        }
    }

    shared_ptr<Empty> getValue() {
        shared_ptr<Empty> p = this->value.lock();
        if (p) {
            cout << "stored value : " << p << endl;
        } else {
            cout << "there's nothing here !" << endl;
        }
        return p;
    }
};

int main()
{
    shared_ptr<Empty> e(new Empty);
    shared_ptr<Store> st(new Store);

    st->setValue(e);
    st->getValue();
    return 0;
}

编译并运行它将为您提供：

%> ./a.out 
storing 0x8c6c008
ok, v has been stored
stored value : 0x8c6c008

现在，如果我使用boost python封装它：

#include <iostream>

#include <boost/shared_ptr.hpp>
#include <boost/python.hpp>
#include <boost/weak_ptr.hpp>

using namespace std;
using namespace boost;
using namespace boost::python;

struct Empty
{
    Empty(){}
};

struct Store
{
    weak_ptr<Empty> value;
    Store(){};

    void setValue(shared_ptr<Empty> v) {
        cout << "storing " << v << endl;
        this->value = weak_ptr<Empty>(v);
        shared_ptr<Empty> v_ok = this->value.lock();
        if (v_ok) {
            cout << "ok, v has been stored" << endl;
        }
    }

    shared_ptr<Empty> getValue() {
        shared_ptr<Empty> p = this->value.lock();
        if (p) {
            cout << "stored value : " << p << endl;
        } else {
            cout << "there's nothing here !" << endl;
        }
        return p;
    }
};

BOOST_PYTHON_MODULE (test)
{
    class_< Empty, shared_ptr<Empty> >("Empty");

    class_< Store, shared_ptr<Store> >("Store")
    .def("get",&Store::getValue)
    .def("set",&Store::setValue);
}

现在是一个小的python脚本来试用它

from test import *

e = Empty()
st = Store()

st.set(e)
st.get()

......结果是......

storing 0x9eb2a18
ok, v has been stored
there's nothing here !

显然，当我仍然使用相同的方法（setValue）时，检索一个没有问题 Store :: value中的shared_ptr。但是一旦我摆脱这种背景，就没有什么了！

这怎么可能？ python是否将一个全新的（无用的）shared_ptr作为参数传递给setValue，然后在调用结束时将其销毁？我迷路了。

Answer 1

这非常好奇。我已经排除了std vs. boost共享指针的可能性，并且进行了一些完整性检查，并且据我所知，它是提升python对共享指针的影响它

跟踪对象构造函数/析构函数，正在按照您的预期管理Empty和Store的生命周期（不会发生副本）。

一个非常有趣的事情是shared_from_this继续工作，即使weak_ptr<>.lock()没有，事实上，一个新的弱指针是从一个新共享创建的指针（来自shared_from_this）确实有效。

所以这导致我the thread linked in the comments，似乎有一些提升python正在做的删除和引用计数正在打破弱指针。

检查调试器中的共享指针这是我们得到的：

当我们致电 setValue 时，这就是参数的样子：

1: p = (const 'boost::shared_ptr<Empty>' &) @0x7fff5fbfe720: {
  px = 0x100346900, 
  pn = {
    pi_ = 0x100338dd0
  }
}
> p *p.pn.pi_
$5 = (boost::detail::sp_counted_impl_pd<void*,boost::python::converter::shared_ptr_deleter>) {
  <boost::detail::sp_counted_base> = {
    _vptr$sp_counted_base = 0x10061aa30, 
    use_count_ = 2, 
    weak_count_ = 2
  }, 
  members of boost::detail::sp_counted_impl_pd<void*,boost::python::converter::shared_ptr_deleter>: 
  ptr = 0x0, 
  del = {
    owner = {
      m_p = 0x10049db90
    }
  }
}

如果我们在参数上使用shared_from_this创建共享指针，它看起来像这样：

1: p = (const 'boost::shared_ptr<Empty>' &) @0x7fff5fbfe5e0: {
  px = 0x100346900, 
  pn = {
    pi_ = 0x1003468e0
  }
}
> p *p.pn.pi_
$4 = (boost::detail::sp_counted_impl_pd<Empty*,boost::detail::sp_ms_deleter<Empty> >) {
  <boost::detail::sp_counted_base> = {
    _vptr$sp_counted_base = 0x10061b170, 
    use_count_ = 2, 
    weak_count_ = 2
  }, 
  members of boost::detail::sp_counted_impl_pd<Empty*,boost::detail::sp_ms_deleter<Empty> >: 
  ptr = 0x0, 
  del = {
    initialized_ = true, 
    storage_ = {
      data_ = "\000i4\000\001\000\000\000?h4\000\001\000\000", 
      align_ = {<No data fields>}
    }
  }
}

这里有一点需要注意：共享计数的地址不同：这是一个不同的共享指针实例...所以我们以某种方式创建了两个不同的共享指针到同一个地址。这是一件非常糟糕的事情，因为我们预计这会很快导致双重免费。

然而，它没有。（如果有人有任何想法，我非常希望进一步理解这一点吗？）

我不知道为什么它没有，说实话（可能这里有一些微妙的东西），但无论如何，所有这些都指向一个解决方案：我们可以使用shared_from_this来从传递的值创建一个共享指针，我们可以使用它来创建一个实际工作的弱指针。

所以，总结一下，这是修复：

#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/python.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

namespace bp = boost::python;

struct Empty: boost::enable_shared_from_this<Empty>{ };

struct Store
{
    boost::weak_ptr<Empty> value;

    void setValue(boost::shared_ptr<Empty> const& v) {
        value = boost::weak_ptr<Empty>(v->shared_from_this());
        boost::shared_ptr<Empty> v_ok = value.lock();
        if (v_ok) {
            std::cout << "ok, v has been stored" << std::endl;
        }
    }

    boost::shared_ptr<Empty> getValue() {
        boost::shared_ptr<Empty> p = value.lock();
        if (p) {
            std::cout << "stored value : " << p << std::endl;
        } else {
            std::cout << "there's nothing here !" << std::endl;
        }
        return p;
    }
};

BOOST_PYTHON_MODULE (libmylibinterface)
{
    bp::class_< Empty, boost::shared_ptr<Empty> >("Empty",bp::init<>())
        ;

    bp::class_< Store, boost::shared_ptr<Store> >("Store")
        .def("get",&Store::getValue)
        .def("set",&Store::setValue);

}

Answer 2

另一种解决方法是传入对shared_ptr的引用，而不是shared_ptr对象本身。在这种情况下，boost::python-Wrapper显然没有创建这个奇怪的单独shared_ptr。

顺便说一下。我看一下shared_ptr.pn.pi_所指向的类的类型，你会看到发给Python的“原始”shared_ptr包含指向sp_counted_impl_p<POINTEE_TYPE>对象的指针而shared_ptr对象从Python传回的1}}包含指向sp_counted_impl_pd<void*，shared_ptr_deleter> object的指针（参见smart_ptr/detail/sp_counted_impl.hpp） pd变体不包含对pointee的引用。我怀疑这个sp_counted_impl_pd对象以某种方式引用sp_counted_impl_p对象。这可以解释为什么当从Python传回来的shared_ptr的引用计数降为零时，不会调用析构函数。 weak_ptr在这种情况下不起作用的事实可能只是一个错误然后......？

boost :: python和weak_ptr：东西消失了

2 个答案: