如何包装C++；使用构造函数初始化，该构造函数使用Boost.Python接受std:：map或std:：vector参数？

免责声明：是的，我确实知道

boost:：python:：map\u index\u suite

<强>任务：我有一个C++类，我想用Boost.Python来包装它。它的构造函数采用

std:：map

参数。这里是C++标题：

// myclass.hh
typedef std::map<int, float> mymap_t;

class MyClass {
  public:
  explicit MyClass(const mymap_t& m);
  // ...
};
// ...

口译员抱怨（这是正确的）：

Boost.Python.ArgumentError:中的Python参数类型
MyClass.\uuuu初始化（MyClass，dict）
与C++签名不匹配：
__将应用来自python转换器的init_uuuu（_object*，std:：uuu 1:：mapstd:：map）

我失去了信心：-）
我找到了一个很好的解决方案：添加了一个模板，可以将Python字典转换为
std:：map
。该逻辑基于，稍作修改，主要从和一些附加注释中获得

以下是模板定义：

// 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;
    }
};

现在可以在Python端创建
MyClass
对象，如下所示：

myclass = MyClass({"foo":1, "bar":2})

 <强>编辑< /St>：Python列表可以以类似的方式转换为C++ <代码> STD:：vector < /CODE> -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;
    }
};

模板
结构列表2vec{
///我们将Python列表转换为的向量的类型
typedef std：：向量向量；
///建造师
///注册转换器
List2Vec（）{
bpy:：转换器：：注册表：：推回(
&可兑换的，
&建设,，
bpy:：type_id（）
#ifdef BOOST_PYTHON_支持_PY_签名
，&bpy:：converter:：wrap_pytype:：get_pytype
#恩迪夫
);
}
///检查是否可以进行转换
静态void*可转换（PyObject*objptr）{
返回PyList_检查（objptr）？objptr:nullptr；
}
///执行转换
静态空洞构造(
PyObject*objptr，
bpy:：converter:：rvalue_from_python_stage1_data*数据
) {
//将`objptr`指向的PyObject转换为bpy:：list
bpy:：handle objhandle{bpy:：followed（objptr）}；/“智能ptr”
列表lst{objhandle}；
//获取一个指向我们构造向量的内存的指针
//这是由Python端提供的
无效*存储=
重新解释<
bpy:：converter:：rvalue\u来自python\u存储*
>（数据）->storage.bytes；
//放置新的分配结果
新（存储）向量{}；
//迭代列表'lst'，填充向量'vec'`
int elemcount{static_cast（bpy:：len（lst））}；
vec_t&vec{*（静态（存储））}；
对于（int i=0；i可转换=存储；
}
};
创建一个独立函数，该函数将从
boost:：python:：dict
构建对象。丹玛舍克：非常感谢，你的评论非常有用，它把我引向了转换器。我现在回答了我自己的问题，见下文。
// 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;
    }
};

// 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 = MyClass({"foo":1, "bar":2})

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;
    }
};