文章/答案/技术大牛

发布

社区首页 >问答首页 >Boost.Python:如何公开std::unique_ptr

问Boost.Python:如何公开std::unique_ptr
EN

Stack Overflow用户

提问于 2013-12-14 09:34:10

回答 4查看 4.2K关注 0票数 24

我对boost.python相当陌生，并试图将函数的返回值公开给python。

函数签名如下所示：

 std::unique_ptr<Message> someFunc(const std::string &str) const;

在python中调用函数时，我得到以下错误：

TypeError: No to_python (by-value) converter found for C++ type: std::unique_ptr<Message, std::default_delete<Message> >

我在python中的函数调用如下所示：

a = mymodule.MyClass()
a.someFunc("some string here") # error here

我试着暴露std::unique_ptr，但就是不能让它正常工作。有人知道如何正确地公开指针类吗？谢谢!

编辑：，我尝试了以下几种方法：

class_<std::unique_ptr<Message, std::default_delete<Message>>, bost::noncopyable ("Message", init<>())

;

这个例子编译，但我仍然得到上面提到的错误。此外，我还试图公开类Message本身。

class_<Message>("Message", init<unsigned>())

        .def(init<unsigned, unsigned>()) 
        .def("f", &Message::f)
;

boost-python

python

c++

c++11

unique-ptr

回答 4

Stack Overflow用户

回答已采纳

发布于 2013-12-23 06:56:42

简而言之，Boost.Python不支持移动语义，因此不支持std::unique_ptr。updated的新闻/变更日志没有迹象表明它已经为C++11移动语义进行了更新。此外，这个用于unique_ptr支持的unique_ptr已经有一年多没有接触过了。

然而，Boost.Python支持通过std::auto_ptr将对象的独占所有权传递给和从Python。由于unique_ptr本质上是一个更安全的auto_ptr版本，因此将使用unique_ptr的API调整为使用auto_ptr的API应该是相当直接的。

当C++将所有权转移给C++时，C++函数必须：
- 使用CallPolicy of boost::python::return_value_policy和boost::python::manage_new_object结果转换器公开。
- 让unique_ptr通过release()发布控制，并返回一个原始指针

当Python将所有权转移给C++时，C++函数必须：
- 通过auto_ptr接受实例。常见问题提到，从带有manage_new_object策略的C++返回的指针将通过std::auto_ptr进行管理。
- 让auto_ptr通过release()向unique_ptr发布控制

给定一个不能更改的API/库：

/// @brief Mockup Spam class.
struct Spam;

/// @brief Mockup factory for Spam.
struct SpamFactory
{
  /// @brief Create Spam instances.
  std::unique_ptr<Spam> make(const std::string&);

  /// @brief Delete Spam instances.
  void consume(std::unique_ptr<Spam>);
};

SpamFactory::make()和SpamFactory::consume()需要通过辅助函数包装。

将所有权从C++转移到Python的函数一般可以由创建Python对象的函数包装：

/// @brief Adapter a member function that returns a unique_ptr to
///        a python function object that returns a raw pointer but
///        explicitly passes ownership to Python.
template <typename T,
          typename C,
          typename ...Args>
boost::python::object adapt_unique(std::unique_ptr<T> (C::*fn)(Args...))
{
  return boost::python::make_function(
      [fn](C& self, Args... args) { return (self.*fn)(args...).release(); },
      boost::python::return_value_policy<boost::python::manage_new_object>(),
      boost::mpl::vector<T*, C&, Args...>()
    );
}

lambda委托给原始函数，releases()对实例的所有权委托给Python，调用策略指示Python将获得从lambda返回的值的所有权。mpl::vector描述了对Boost.Python的调用签名，允许它正确地管理语言之间的函数分配。

adapt_unique的结果公开为SpamFactory.make()。

boost::python::class_<SpamFactory>(...)
  .def("make", adapt_unique(&SpamFactory::make))
  // ...
  ;

一般性地适应SpamFactory::consume()是一个比较困难的问题，但是编写一个简单的辅助函数是非常容易的：

/// @brief Wrapper function for SpamFactory::consume_spam().  This
///        is required because Boost.Python will pass a handle to the
///        Spam instance as an auto_ptr that needs to be converted to
///        convert to a unique_ptr.
void SpamFactory_consume(
  SpamFactory& self,
  std::auto_ptr<Spam> ptr) // Note auto_ptr provided by Boost.Python.
{
  return self.consume(std::unique_ptr<Spam>{ptr.release()});
}

辅助函数将委托给原始函数，并将Boost.Python提供的Boost.Python提供的unique_ptr转换为API所需的unique_ptr。SpamFactory_consume辅助函数公开为SpamFactory.consume()

boost::python::class_<SpamFactory>(...)
  // ...
 .def("consume", &SpamFactory_consume)
 ;

下面是一个完整的代码示例：

#include <iostream>
#include <memory>
#include <boost/python.hpp>

/// @brief Mockup Spam class.
struct Spam
{
  Spam(std::size_t x) : x(x) { std::cout << "Spam()" << std::endl; }
  ~Spam() { std::cout << "~Spam()" << std::endl; }
  Spam(const Spam&) = delete;
  Spam& operator=(const Spam&) = delete;
  std::size_t x;
};

/// @brief Mockup factor for Spam.
struct SpamFactory
{
  /// @brief Create Spam instances.
  std::unique_ptr<Spam> make(const std::string& str)
  {
    return std::unique_ptr<Spam>{new Spam{str.size()}};
  }

  /// @brief Delete Spam instances.
  void consume(std::unique_ptr<Spam>) {}
};

/// @brief Adapter a non-member function that returns a unique_ptr to
///        a python function object that returns a raw pointer but
///        explicitly passes ownership to Python.
template <typename T,
          typename ...Args>
boost::python::object adapt_unique(std::unique_ptr<T> (*fn)(Args...))
{
  return boost::python::make_function(
      [fn](Args... args) { return fn(args...).release(); },
      boost::python::return_value_policy<boost::python::manage_new_object>(),
      boost::mpl::vector<T*, Args...>()
    );
}

/// @brief Adapter a member function that returns a unique_ptr to
///        a python function object that returns a raw pointer but
///        explicitly passes ownership to Python.
template <typename T,
          typename C,
          typename ...Args>
boost::python::object adapt_unique(std::unique_ptr<T> (C::*fn)(Args...))
{
  return boost::python::make_function(
      [fn](C& self, Args... args) { return (self.*fn)(args...).release(); },
      boost::python::return_value_policy<boost::python::manage_new_object>(),
      boost::mpl::vector<T*, C&, Args...>()
    );
}

/// @brief Wrapper function for SpamFactory::consume().  This
///        is required because Boost.Python will pass a handle to the
///        Spam instance as an auto_ptr that needs to be converted to
///        convert to a unique_ptr.
void SpamFactory_consume(
  SpamFactory& self,
  std::auto_ptr<Spam> ptr) // Note auto_ptr provided by Boost.Python.
{
  return self.consume(std::unique_ptr<Spam>{ptr.release()});
}

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;
  python::class_<Spam, boost::noncopyable>(
      "Spam", python::init<std::size_t>())
    .def_readwrite("x", &Spam::x)
    ;

  python::class_<SpamFactory>("SpamFactory", python::init<>())
    .def("make", adapt_unique(&SpamFactory::make))
    .def("consume", &SpamFactory_consume)
    ;
}

交互式Python：

>>> import example
>>> factory = example.SpamFactory()
>>> spam = factory.make("a" * 21)
Spam()
>>> spam.x
21
>>> spam.x *= 2
>>> spam.x
42
>>> factory.consume(spam)
~Spam()
>>> spam.x = 100
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Boost.Python.ArgumentError: Python argument types in
    None.None(Spam, int)
did not match C++ signature:
    None(Spam {lvalue}, unsigned int)

票数 21

Stack Overflow用户

发布于 2013-12-16 13:53:17

我的建议是使用std::unique_ptr从get()容器中获取原始指针。在希望使用原始指针值的整个时间内，您必须小心地将unique_ptr保持在范围内，否则对象将被删除，并且将有指向无效内存区域的指针。

票数 4

Stack Overflow用户

发布于 2014-01-11 06:45:38

Boost支持movable semantics和unique_ptr 自第1.55节起。但是在我的项目中，我使用了以前的版本，并做了这样简单的包装：

class_<unique_ptr<HierarchyT>, noncopyable>(typpedName<LinksT>("hierarchy", false)
, "hierarchy holder")
    .def("__call__", &unique_ptr<HierarchyT>::get,
        return_internal_reference<>(),
        "get holding hierarchy")
    .def("reset", &unique_ptr<HierarchyT>::reset,
        "reset holding hierarhy")
    ;

将unique_ptr<HierarchyT>创建为shierarchy，并将其传递给通过引用接受它的函数。

Python代码：

hier = mc.shierarchy()
mc.clusterize(hier, nds)

其中C++函数是float clusterize(unique_ptr<HierarchyT>& hier,...)。

然后，要在Python中访问结果，请调用hier()从unique_ptr中获取包装的对象：

output(hier(), nds)

票数 1

页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持

原文链接：

https://stackoverflow.com/questions/20581679

复制

相似问题

问Boost.Python:如何公开std::unique_ptr
EN

回答 4

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Boost.Python:如何公开std::unique_ptrEN

回答 4

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Boost.Python:如何公开std::unique_ptr
EN