boost python返回包含自定义类型的元组

Question

我有一个C++ MyObjor类，它通过PrimePython使用包装器结构公开：

struct myObjectWrapper{
   static tuple compute(myObject& o,const Container& x0, const double& t0, Container& x){
      double t;
      int stat = o.evaluate(x0,t0,x,t);
      return make_tuple(stat,t);
   }
}

BOOST_PYTHON_MODULE(myModule)
{
   // not shown here is code to expose Container class

   class_<myObject>("MyObject")
      .def("compute",&myObjectWrapper::compute)
   ;
}

容器当前定义为：

^{pr2}$

并暴露在python中。在

现在我可以用python了。在

x = Container()
(status,t) = obj.compute(Container([0.,0.,0.]),0.0,x)
print status, t, x[0]

这不是很像Python。我更愿意这样做：

(status,t,x) = obj.compute(Container([0.,0.,0.]),0.0)
print status, t, x[0]    

我可以用python编写一个额外的包装器，但我宁愿避免添加更多的包装器。在

以下代码无法编译：

struct myObjectWrapper{
   static tuple compute(myObject& o,const Container& x0, const double& t0){
      double t;
      Container x;
      int stat = o.evaluate(x0,t0,x,t);
      return make_tuple(stat,t,x);
   }
}

另外，我更愿意窃取局部变量x的内容，让python管理它而不是复制它：

return make_tuple(stat,t,std::move(x));

我如何实现这一点？在

Answer 1

简而言之，在空闲存储区分配包装器并使用^{}result convert将所有权转移到Python对象。这会导致Boost.Python在构造Python对象时复制指针，而不是复制指针对象。有关详细信息，请参阅this答案。在

下面是一个将所有权转移到Python对象的辅助函数：

/// @brief Transfer ownership to a Python object.  If the transfer fails,
///        then object will be destroyed and an exception is thrown.
template <typename T>
boost::python::object transfer_to_python(T* t)
{
  // Transfer ownership to a smart pointer, allowing for proper cleanup
  // incase Boost.Python throws.
  std::unique_ptr<T> ptr(t);

  // Use the manage_new_object generator to transfer ownership to Python.
  namespace python = boost::python;
  typename python::manage_new_object::apply<T*>::type converter;

  // Transfer ownership to the Python handler and release ownership
  // from C++.
  python::handle<> handle(converter(*ptr));
  ptr.release();

  return python::object(handle);
}

我们可以这样使用它：

^{pr2}$

---

下面是一个完整的例子，它基于原始问题demonstrates使用transfer_to_python辅助函数。在

#include <boost/python.hpp>
#include <cassert>
#include <memory> // std::unique_ptr

// Mock legacy API.
struct container
{
  container() {}
  container(boost::python::object) {}

  container(const container&)
  {
    // For this example, guarantee copy is not made.
    assert(false);
   }
};

struct my_object
{
  int evaluate(container&, double&, container&, double&) { return 42; }
};

/// @brief Transfer ownership to a Python object.  If the transfer fails,
///        then object will be destroyed and an exception is thrown.
template <typename T>
boost::python::object transfer_to_python(T* t)
{
  // Transfer ownership to a smart pointer, allowing for proper cleanup
  // incase Boost.Python throws.
  std::unique_ptr<T> ptr(t);

  // Use the manage_new_object generator to transfer ownership to Python.
  namespace python = boost::python;
  typename python::manage_new_object::apply<T*>::type converter;

  // Transfer ownership to the Python handler and release ownership
  // from C++.
  python::handle<> handle(converter(*ptr));
  ptr.release();

  return python::object(handle);
}

// API wrapper.
boost::python::tuple my_object_compute(
  my_object& self, container& x0, double t0)
{
  auto x1 = std::make_unique<container>();
  double t1 = 21;
  int stat = self.evaluate(x0, t0, *x1, t1);
  return boost::python::make_tuple(stat, t1, transfer_to_python(x1.release()));
}

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;

  python::class_<container>("Container")
    .def(python::init<python::object>())
    ;

  python::class_<my_object>("MyObject")
    .def("compute", &my_object_compute)
    ;
}

交互式使用：

>>> import example
>>> my_object = example.MyObject()
>>> status, t, x = my_object.compute(example.Container([1, 2, 3]), 4)
>>> assert(status == 42)
>>> assert(t == 21)
>>> assert(isinstance(x, example.Container))