Boost.Python y C++ std :: vector de punteros

Question

Estoy usando Boost.Python para crear un contenedor para mi biblioteca C++, y estoy teniendo algunos problemas, buscando en Google todo el día no produjo ningún resultado. Por ejemplo, tengo el siguiente código:

class Base 
{ 
public: 
    virtual void func() = 0; 
}; 

class Derived : public Base 
{ 
public: 
    virtual void func() 
    { 
     cout << "Derived::func()"<< endl; 
    } 
}; 


// wrapper for Base 
struct BaseWrapper : Base, python::wrapper<Base> 
{ 
    virtual void func() 
    { 
     this->get_override("func"); 
    } 
}; 


Base* makeDerived() 
{ 
    return new Derived; 
} 

vector<Base*>* makeDerivedVec() 
{ 
    vector<Base*> *v = new vector<Base*>; 
    v->push_back(new Derived); 
    v->push_back(new Derived); 
    v->push_back(new Derived); 
    return v; 
} 

BOOST_PYTHON_MODULE(mylib) 
{ 
    // export Base 
    class_<BaseWrapper, noncopyable>("Base") 
      .def("func", pure_virtual(&Base::func)); 

    class_<vector<Base*> >("BasePtrVec") 
      .def(vector_indexing_suite<vector<Base*> >()); 

    // export Derived 
    class_<Derived, bases<Base> >("Derived") 
      .def("func", &Derived::func); 

    // export makeDerived() 
    def("makeDerived", &makeDerived, return_value_policy<manage_new_object>()); 

    // export makeDerivedVec() 
    def("makeDerivedVec", &makeDerivedVec, return_value_policy<manage_new_object>()); 
} 

Por lo tanto, compilarlo, la importación en Python y prueba esto:

b = mylib.Base() b.func()

d = mylib.makeDerived() d.func()

la primera línea, como se esperaba, se produce una excepción diciendo que b.func() es puro virtual, y la segunda línea imprime

Derivado :: func()

Y eso está bien.

Pero el código

dlist = mylib.makeDerivedVec() 
for d in dlist: 
    d.func() 

no funciona, y Python lanza una excepción:

TypeError: No to_python (by-value) converter found for C++ type: Base* 

Por qué se maneja correctamente la Base * devuelto por makeDerived() y se niega a trabajar con la base * contenido en std :: vector? ¿Cómo puedo hacer que funcione?

Answer 1

Puede solucionar este problema mediante el registro Base* como un tipo que puede ser usado para apuntar a un BaseWrapper*:

class_<BaseWrapper, noncopyable, Base*>("Base") 
     .def("func", pure_virtual(&Base::func)); 

Pero parece que esto significa que Base no puede tener una función virtual pura ...