Question

这是我的代码：

// c++ (main.cpp)
#include <vector>
#include <iostream>
#include <boost/python.hpp>
#include <boost/python/enum.hpp>
#include <boost/python/def.hpp>
#include <boost/python/module.hpp>

using namespace std;
using namespace boost;
using namespace boost::python;

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

class Stack
{
public:
Stack(void) {}
void push(Base *e)
{
    stack.push_back(e);
}
void pushPython(boost::python::object &o)
{
    Base &e = extract<Base &>(o) BOOST_EXTRACT_WORKAROUND;
    push(&e);
}
void test(void)
{
    for(std::vector<Base *>::iterator i = stack.begin(); i != stack.end(); i++)
    {
        (*i)->f1();
        (*i)->f2();
    }
}
private:
std::vector<Base *> stack;
};


class DerivedCPP : public Base
{
public:
DerivedCPP(void) {}
virtual void f1(void)
{
    std::cout << "DerivedCPP f1()" << std::endl;
}
virtual void f2(void)
{
    std::cout << "DerivedCPP f2()" << std::endl;
}
};

BOOST_PYTHON_MODULE(mytest)
{
boost::python::class_<Base,boost::noncopyable>("Base",boost::python::no_init)
    .def( "f1", &Base::f1)
    .def( "f2", &Base::f2)
    ;

boost::python::class_<DerivedCPP,bases<Base>>("DerivedCPP")
    .def( "f1", &DerivedCPP::f1)
    .def( "f2", &DerivedCPP::f2)
    ;

boost::python::class_<Stack>("Stack", boost::python::no_init)
    .def( "push", &Stack::pushPython)
    .def( "test", &Stack::test)
    ;
}

int main(int argc, char** argv)
{
PyImport_AppendInittab("mytest", &initmytest);
Py_Initialize();
boost::python::object main_module(( handle<>( borrowed( PyImport_AddModule( "__main__" )))));
boost::python::object main_namespace = main_module.attr("__dict__");
boost::python::object mytest( (handle<>(PyImport_ImportModule("mytest"))) );
main_namespace["mytest"] = mytest;
Stack *STACK = new Stack();
main_namespace["Stack"] = ptr(STACK);
Base *e = new DerivedCPP();
STACK->push(e);
STACK->test();
boost::python::object main = import("__main__");
boost::python::object global(main.attr("__dict__"));
boost::python::object result = exec_file("test.py", global, global);
Py_Finalize();
return 0;
}


# python (test.py)
print 'test.py'
print

class DerivedPython(mytest.Base):
def __init__(self):
    print "DerivedPython __init__()"
def f1(self):
    print "DerivedPython f1()"
def f2(self):
    print "DerivedPython f2()"

print 'DerivedPython()'
p = DerivedPython()
p.f1()
p.f2()

print 'mytest.DerivedCPP()'
c = mytest.DerivedCPP()
c.f1()
c.f2()

print 'Stack.push(c)'
Stack.push(c)
print 'OK'

print "Stack.test()"
Stack.test()

print 'Stack.push(p)'
Stack.push(p) # crash!
print 'OK'

print "Stack.test()"
Stack.test()

我想创建从c ++抽象类派生的python类，然后将此对象传递回c ++。如果没有崩溃我该怎么做？

Answer 1

这有点复杂，但并不困难。阅读this page，它应该为您提供所需的一切。

你需要像这样包装抽象类：

struct BaseWrap : Base, wrapper<Base>
{
    void f1()
    {
        this->get_override("f1")();
    }

    void f2()
    {
        this->get_override("f2")();
    }

};

然后你必须按如下方式公开Base：

class_<BaseWrap, boost::noncopyable>("Base")
    .def("f1", pure_virtual(&Base::f1))
    .def("f2", pure_virtual(&Base::f2))
    ;

Answer 2

您可能还想查看Py++包。它是一个实用程序，用于解析C ++代码，并为该代码生成boost :: python包装器。我只尝试了一点，但它似乎处理自动创建基类包装器和类似的东西（根据文档，作者能够导出几个boost库并通过生成绑定通过生成绑定在Python中运行他们的测试套件PY ++）。

如何创建派生自抽象c ++类的类的python对象实例？

2 个答案: