c++ - nonlocal - python global variable in function

Boost.Python call by reference: TypeError: No se ha encontrado el convertidor to_python(by-value) para el tipo C++:

Question

Estoy tratando de exponer mis clases de C ++ a Python usando Boost.Python. Aquí hay una versión simplificada de lo que estoy tratando de hacer:

Tengo una clase A que deriva de boost :: noncopyable y una segunda clase B con un método que toma una referencia a A como argumento.

class A : boost::noncopyable { /*...*/ };

class B {

public:

    virtual void do_something(A& a) {
        /*...*/
    }
};

Estoy exponiendo las clases de la siguiente manera:

/* Wrapper for B, so B can be extended in python */
struct BWrap : public B, wrapper<B> {

    void do_something(A &a) {

        if (override do_something = this->get_override("do_something")) {
            do_something(a);
            return;
        }
        else {
            B::do_something(a);
        }
    }

    void default_do_something(A& a) { this->B::do_something(a); }
};

BOOST_PYTHON_MODULE(SomeModule) {

    class_<A, boost::noncopyable>("A");

    class_<BWrap, boost::noncopyable>("B")
        .def("do_something", &B::do_something, &BWrap::default_do_something)
    ;
}

Extiendo B en python así:

test.py:

import SomeModule


class BDerived(SomeModule.B):

    def do_something(self, a):
        pass

y llamar a la B extendida de esta manera:

try {
    py::object main = py::import("__main__"); /
    py::object global(main.attr("__dict__")); /
    py::object result = py::exec_file("test.py", global, global); /
    py::object pluginClass = global["BDerived"]; /
    py::object plugin_base = pluginClass(); /

    B& plugin = py::extract<B&>(plugin_base) BOOST_EXTRACT_WORKAROUND;

    A a;
    B.do_something(a);
}
catch (py::error_already_set) { 
    PyErr_Print();
}

Sin embargo, esto resulta en un mensaje de error:

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

Si A no se deriva de boost::noncopyable el código se ejecuta sin ningún error, pero el argumento a en do_something(A& a) se copia durante la llamada a la función, aunque se pasa por referencia. Pero solo eliminar el requisito no copiable en A no es una opción, ya que está ahí por una razón.

¿Alguna sugerencia de cómo resolver el problema?

Gracias.

Answer 1

Cambiar B.do_something(a); a B.do_something(boost::ref(a)); .

Consulte Llamar a funciones y métodos de Python en el manual de boost.