免责声明:是的，我知道 boost::python::map_indexing_suite .
任务:我有一个 C++ 类，我想用 Boost.Python 包装它。它的构造函数采用 std::map争论。这是 C++ header :
// myclass.hh
typedef std::map<int, float> mymap_t;
class MyClass {
public:
explicit MyClass(const mymap_t& m);
// ...
};
// ...
这是 Boost.Python 包装器(仅重要部分):
// myclasswrapper.cc
#include "mymap.hh"
#include "boost/python.hpp"
#include "boost/python/suite/indexing/map_indexing_suite.hpp"
namespace bpy = boost::python;
// wrapping mymap_t
bpy::class_<mymap_t>("MyMap")
.def(bpy::map_indexing_suite<mymap_t>())
;
// wrapping MyClass
bpy::class_<MyClass>("MyClass", "My example class",
bpy::init<mymap_t>() // ??? what to put here?
)
// .def(...method wrappers...)
;
这编译。但是，我无法创建映射 MyClass来自 Python 端的对象，因为我不知道将什么作为参数传递给构造函数。字典不会转换为 std::map -s 自动:
# python test
myclass = MyClass({1:3.14, 5:42.03})
口译员提示(理所当然):
Boost.Python.ArgumentError: Python argument types in
MyClass.__init__(MyClass, dict)
did not match C++ signature:
__init__(_object*, std::__1::map<int, float, ...
和MyMap在 Python 端也不能用字典初始化。
在谷歌搜索了一天中最精彩的部分后，我只能找到采用 std::map 的“正常”方法的示例。用 .def(...) 映射的参数.而在 .def(...)您不必明确指定映射方法的参数，它们会被神奇地发现。对于构造函数，您必须使用 boost::python::init<...>() ，或者至少这是我从文档中了解到的。
问题:
- 我可以在
MyMap中添加一些内容吗？包装帮助map_indexing_suite从 Python 字典转换？ - 我可以在
boost::python::init<...>中使用不同的模板参数吗？在MyClass包装？ - 还有其他想法吗？
注意:我也看到了this accepted answer at SO ，然后我向下滚动并阅读@YvesgereY 的评论:
"For the record, map_indexing_suite solution doesn't work, since no implicit "dict->std::map" from_python converter will be applied."
然后我失去了信心:-)
请您参考如下方法:
我找到了一个很好的解决方案:添加了一个可以将 Python 字典转换为 std::map 的模板。 .逻辑基于this extremely useful primer , 稍作修改主要来自 this source file以及一些额外的评论。
下面是模板定义:
// dict2map.hh
#include "boost/python.hpp"
namespace bpy = boost::python;
/// This template encapsulates the conversion machinery.
template<typename key_t, typename val_t>
struct Dict2Map {
/// The type of the map we convert the Python dict into
typedef std::map<key_t, val_t> map_t;
/// constructor
/// registers the converter with the Boost.Python runtime
Dict2Map() {
bpy::converter::registry::push_back(
&convertible,
&construct,
bpy::type_id<map_t>()
#ifdef BOOST_PYTHON_SUPPORTS_PY_SIGNATURES
, &bpy::converter::wrap_pytype<&PyDict_Type>::get_pytype
#endif
);
}
/// Check if conversion is possible
static void* convertible(PyObject* objptr) {
return PyDict_Check(objptr)? objptr: nullptr;
}
/// Perform the conversion
static void construct(
PyObject* objptr,
bpy::converter::rvalue_from_python_stage1_data* data
) {
// convert the PyObject pointed to by `objptr` to a bpy::dict
bpy::handle<> objhandle{ bpy::borrowed(objptr) }; // "smart ptr"
bpy::dict d{ objhandle };
// get a pointer to memory into which we construct the map
// this is provided by the Python runtime
void* storage =
reinterpret_cast<
bpy::converter::rvalue_from_python_storage<map_t>*
>(data)->storage.bytes;
// placement-new allocate the result
new(storage) map_t{};
// iterate over the dictionary `d`, fill up the map `m`
map_t& m{ *(static_cast<map_t *>(storage)) };
bpy::list keys{ d.keys() };
int keycount{ static_cast<int>(bpy::len(keys)) };
for (int i = 0; i < keycount; ++i) {
// get the key
bpy::object keyobj{ keys[i] };
bpy::extract<key_t> keyproxy{ keyobj };
if (! keyproxy.check()) {
PyErr_SetString(PyExc_KeyError, "Bad key type");
bpy::throw_error_already_set();
}
key_t key = keyproxy();
// get the corresponding value
bpy::object valobj{ d[keyobj] };
bpy::extract<val_t> valproxy{ valobj };
if (! valproxy.check()) {
PyErr_SetString(PyExc_ValueError, "Bad value type");
bpy::throw_error_already_set();
}
val_t val = valproxy();
m[key] = val;
}
// remember the location for later
data->convertible = storage;
}
};
为了使用它，您必须创建一个 Dict2Map实例，以便调用其构造函数。一种可能的方法是创建一个静态的 Dict2Map<key_t, val_t>定义 Python 包装器的源文件中的变量。使用我的示例:
// myclasswrapper.cc
#include "mymap.hh"
#include "dict2map.hh"
// register the converter at runtime
static Dict2Map<char, double> reg{};
#include "boost/python.hpp" // not really necessary
namespace bpy = boost::python;
// wrapping MyClass
bpy::class_<MyClass>("MyClass", "My example class",
bpy::init<mymap_t>()
)
// .def(...method wrappers...)
;
现在可以创建MyClass Python 端的对象是这样的:
myclass = MyClass({"foo":1, "bar":2})
编辑:Python 列表可以转换为 C++ std::vector -s 以类似的方式。这是相应的模板:
template<typename elem_t>
struct List2Vec {
/// The type of the vector we convert the Python list into
typedef std::vector<elem_t> vec_t;
/// constructor
/// registers the converter
List2Vec() {
bpy::converter::registry::push_back(
&convertible,
&construct,
bpy::type_id<vec_t>()
#ifdef BOOST_PYTHON_SUPPORTS_PY_SIGNATURES
, &bpy::converter::wrap_pytype<&PyList_Type>::get_pytype
#endif
);
}
/// Check if conversion is possible
static void* convertible(PyObject* objptr) {
return PyList_Check(objptr)? objptr: nullptr;
}
/// Perform the conversion
static void construct(
PyObject* objptr,
bpy::converter::rvalue_from_python_stage1_data* data
) {
// convert the PyObject pointed to by `objptr` to a bpy::list
bpy::handle<> objhandle{ bpy::borrowed(objptr) }; // "smart ptr"
bpy::list lst{ objhandle };
// get a pointer to memory into which we construct the vector
// this is provided by the Python side somehow
void* storage =
reinterpret_cast<
bpy::converter::rvalue_from_python_storage<vec_t>*
>(data)->storage.bytes;
// placement-new allocate the result
new(storage) vec_t{};
// iterate over the list `lst`, fill up the vector `vec`
int elemcount{ static_cast<int>(bpy::len(lst)) };
vec_t& vec{ *(static_cast<vec_t *>(storage)) };
for (int i = 0; i < elemcount; ++i) {
// get the element
bpy::object elemobj{ lst[i] };
bpy::extract<elem_t> elemproxy{ elemobj };
if (! elemproxy.check()) {
PyErr_SetString(PyExc_ValueError, "Bad element type");
bpy::throw_error_already_set();
}
elem_t elem = elemproxy();
vec.push_back(elem);
}
// remember the location for later
data->convertible = storage;
}
};
