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，似乎提升 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 的指针包含指向 sp_counted_impl_pd<void*、shared_ptr_deleter> object 的指针（参见 smart_ptr/detail/sp_counted_impl.hpp） pd 变体不包含对指针对象的引用。我怀疑这个sp_counted_impl_pd 对象以某种方式引用了sp_counted_impl_p 对象。这可以解释为什么当从 Python 传回的shared_ptr 的引用计数下降到零时，为什么不调用析构函数。 weak_ptr 在这种情况下不起作用的事实可能只是一个错误......？