2

我正在使用 Boost Python 为 wxWidgets 的一个子集创建绑定。wxWidgets 中的窗口对象不应手动删除，因为它们自己处理删除操作：例如，当用户单击关闭按钮关闭顶层窗口时，它会自动删除自身。如果窗口被删除，事件处理程序等会发生奇怪的事情。

（详情：http ://docs.wxwidgets.org/2.8/wx_windowdeletionoverview.html ）

然而，这会导致在 Python 中创建的窗口对象出现问题：在垃圾回收时，C++ 对象总是被删除！

有什么方法可以告诉 Boost Python 不要拥有它创建的 C++ 对象的所有权？可能是构造函数的调用策略之类的东西？

（另外，我有点担心如何处理从 C++ 中删除的对象。当关联的 C++ 对象被删除时，Python 对象会发生什么情况？Python 不会以任何方式得到通知。）

4

2 回答 2

7

这可以通过boost::shared_ptrBoost.Python 中的一些设置来完成。

boost::shared_ptr具有接受自定义删除器的构造函数。当shared_ptr的引用计数达到零时，shared_ptr将调用客户删除器，将先前托管的指针作为参数传递。这允许使用不同的释放策略，例如“无操作”或调用wxWindow::Destroy().

class window {};
void no_op(window*) {};
boost::shared_ptr(new window(), &no_op);

当向 Python 公开一个类时，Boost.Python 允许通过HeldType. 在这种情况下，HeldType将是boost::shared_ptr。这允许在 C++ 和 Python 之间发生正确的引用计数，并允许自定义解除分配策略。

boost::python::class_<window, boost::shared_ptr<window>, ...>("Window", ...);

让这些透明地协同工作的诀窍是：

  • 禁止 Boost.Python 创建默认初始化程序 ( __init__)。
  • 显式提供一个__init__函数，该函数将调用一个返回shared_ptr带有自定义删除器的工厂函数。

这是一个模拟window类，旨在仅通过destroy()成员函数销毁。

class window
{
...
private:
  ~window();
public:
  void destroy();
};

定义了一个工厂函数，它将window使用自定义删除器创建一个引用计数对象。destroy()当引用计数达到零时 ，自定义删除器将在对象上调用。

boost::shared_ptr<window> create_window()
{
  return boost::shared_ptr<window>(
    new window(),
    boost::mem_fn(&window::destroy));
}

最后，使用 Boost.Python 公开window类，但抑制默认初始化程序，并透明地将其替换为create_window工厂函数。 

boost::python::class_<window, boost::shared_ptr<window>, 
                      boost::noncopyable>("Window", python::no_init)
  .def("__init__", python::make_constructor(&create_window));

这是一个完整的例子：

#include <iostream>
#include <boost/mem_fn.hpp>
#include <boost/python.hpp>
#include <boost/shared_ptr.hpp>

/// @brief Mockup window class.
class window
{
public:
  window(unsigned int id)
    : id_(id)
  {
    std::cout << "window::window() " << id_ << std::endl;
  }
  void action() { std::cout << "window::action() " << id_ << std::endl; }
  void destroy()
  {
    std::cout << "window::destroy() " << id_ << std::endl;
    delete this;
  }
private:
  ~window() { std::cout << "window::~window() " << id_ << std::endl; }
private:
  unsigned int id_;
};

/// @brief Factory function that will create reference counted window
///        objects, that will call window::destroy() when the reference
///        count reaches zero.
boost::shared_ptr<window> create_window(unsigned int id)
{
  return boost::shared_ptr<window>(
    new window(id),
    boost::mem_fn(&window::destroy));
}

BOOST_PYTHON_MODULE(example) {
  namespace python = boost::python;
  // Expose window, that will be managed by shared_ptr, and transparently
  // constructs the window via a factory function to allow for a custom
  // deleter.
  python::class_<window, boost::shared_ptr<window>, 
                 boost::noncopyable>("Window", python::no_init)
    .def("__init__", python::make_constructor(&create_window))
    .def("action", &window::action)
    ;
}

及其用法：

>>> from example import Window
>>> w1 = Window(1)
window::window() 1
>>> w2 = Window(2)
window::window() 2
>>> w3 = Window(3)
window::window() 3
>>> del w2
window::destroy() 2
window::~window() 2
>>> w3 = None
window::destroy() 3
window::~window() 3
>>> w = w1
>>> del w1
>>> w.action()
window::action() 1
>>> w = None
window::destroy() 1
window::~window() 1

请注意 Python 如何仅在 Python 不再引用该实例时才通知 C++ 删除该对象。因此，在这种情况下，Python 不会尝试与已删除的对象进行交互。希望这可以减轻在 C++ 中删除对象时表达的担忧。

如果在某些情况下 C++ 将删除 Python 中仍然处于活动状态的对象，则考虑使用不透明指针来分隔实现类和句柄类。句柄类可以在转发调用之前检查关联的实现实例是否已被删除，从而允许向 Python 抛出异常。

于 2013-02-19T21:09:55.743 回答
-1

实际上，使用 auto_ptr 有一个更简单的解决方案，甚至在Boost Python FAQ中。Python Wiki上有更多详细信息。到目前为止，它工作得很好。

于 2013-04-30T10:37:52.290 回答