c++ - 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::value 的 shared_ptr。但是一旦我离开这个上下文，就什么都没有了!

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

Answer 1

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

跟踪对象的构造函数/析构函数，Empty 和 Store 的生命周期按照您的预期进行管理(没有复制发生)。

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

所以这引导我到 the thread linked in the comments ，似乎 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);

}