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

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 ::值检索shared_ptr没有问题.但是一旦我摆脱这种背景,就没有什么了!

怎么会这样 ？python是否将一个全新的(无用的)shared_ptr作为参数传递给setValue,然后在调用结束时将其销毁？我迷失在这里.

Answer 1

这是非常令人好奇的。我已经排除了 std 与 boost 共享指针的可能性，并进行了一些健全性检查，据我所知，这是boost python 对共享指针所做的破坏它的事情。

跟踪对象构造函数/析构函数，Empty 和 Store 的生命周期按照您的预期进行管理（不会发生复制）。

一件非常有趣的事情是，shared_from_this即使weak_ptr<>.lock()不工作，它仍然可以继续工作，而且事实上，从新的共享指针（来自shared_from_this）创建的新弱指针确实可以工作。

所以这让我看到了评论中链接的线程，似乎 boost 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);

}