boost :: python: lista de Python para std :: vector

Finalmente, puedo usar std :: vector en python usando el operador []. El truco es simplemente proporcionar un contenedor en la envoltura de C ++ boost que maneje el vector interno:

#include  #include  class world { std::vector myvec; void add(double n) { this->myvec.push_back(n); } std::vector show() { return this->myvec; } }; BOOST_PYTHON_MODULE(hello) { class_<std::vector >("double_vector") .def(vector_indexing_suite<std::vector >()) ; class_("World") .def("show", &World::show) .def("add", &World::add) ; } 

El otro desafío es: ¿Cómo traducir las listas de python en std :: vectoress? Intenté agregar una clase de c ++ esperando un std :: vector como parámetro y agregué el código de envoltorio correspondiente:

 #include  #include  class world { std::vector myvec; void add(double n) { this->myvec.push_back(n); } void massadd(std::vector ns) { // Append ns to this->myvec } std::vector show() { return this->myvec; } }; BOOST_PYTHON_MODULE(hello) { class_<std::vector >("double_vector") .def(vector_indexing_suite<std::vector >()) ; class_("World") .def("show", &World::show) .def("add", &World::add) .def("massadd", &World::massadd) ; } 

Pero si lo hago, termino con el siguiente Boost.Python.ArgumentError:

 >>> w.massadd([2.0,3.0]) Traceback (most recent call last): File "", line 1, in  Boost.Python.ArgumentError: Python argument types in World.massadd(World, list) did not match C++ signature: massadd(World {lvalue}, std::vector<double, std::allocator >) 

¿Alguien puede decirme cómo puedo acceder a las listas de python dentro de mi función c ++?

Gracias daniel

Para hacer que su método C ++ acepte listas de Python, debe usar boost::python::list

 void massadd(boost::python::list& ns) { for (int i = 0; i < len(ns); ++i) { add(boost::python::extract(ns[i])); } } 

Esto es lo que yo uso:

 #include  namespace py = boost::python; template< typename T > inline std::vector< T > to_std_vector( const py::object& iterable ) { return std::vector< T >( py::stl_input_iterator< T >( iterable ), py::stl_input_iterator< T >( ) ); } 

Si encuentra que el tipo de entrada (py :: object) es demasiado liberal, no dude en especificar tipos más estrictos (py :: list en su caso).

Basándome en las respuestas anteriores, creé un ejemplo para acceder a las listas de python en C ++ y para devolver una lista de python desde una función de C ++:

 #include  #include  namespace py = boost::python; // dummy class class drow{ public: std::string word; drow(py::list words); py::list get_chars(); }; // example of passing python list as argument (to constructor) drow::drow(py::list l){ std::string w; std::string token; for (int i = 0; i < len(l) ; i++){ token = py::extract(l[i]); w += token; } this -> word = w; } // example of returning a python list py::list drow::get_chars(){ py::list char_vec; for (auto c : word){ char_vec.append(c); } return char_vec; } // binding with python BOOST_PYTHON_MODULE(drow){ py::class_("drow", py::init()) .def("get_chars", &drow::get_chars); } 

Para un ejemplo de comstackción y un script de prueba de python, eche un vistazo aquí

Gracias Arlaharen y rdesgroppes por los punteros (no se pretende un juego de palabras).

Para obtener la conversión automática de las listas de python, debe definir un convertidor, que

  1. verifica si la lista es convertible a su tipo (es decir, es una secuencia; además, también puede verificar si todos los elementos son del tipo requerido, pero eso también puede manejarse en el segundo paso)
  2. devuelve el nuevo objeto, si el primer paso tuvo éxito; lanzar excepción si un elemento de secuencia no es convertible a lo que necesita.

Ahora no puedo encontrar nada más que mi código, puede copiar y pegar esta plantilla (está especializada al final de ese archivo para varios tipos contenidos).