Boost::Python、静态工厂和继承

Question

我可能有一个比较独特的使用场景，但我觉得应该可以实现——不过现在并没有正常工作。

简单来说，我有一个类，它使用一个静态工厂方法（create），这个方法返回一个指向新创建实例的共享指针（shared_ptr）。这个类还有一个虚函数，我想从Python中重写这个函数，然后在C++中调用它。

也许我的代码能比我的话更清楚地表达我的想法：

#include <string>
#include <iostream>
#include <boost/python.hpp>
#include <boost/enable_shared_from_this.hpp>

using namespace boost::python;
using namespace boost;

//~ Base Class ClassA
class ClassA
    : public enable_shared_from_this<ClassA>
{
protected:
    ClassA(){}
public:

    static shared_ptr<ClassA> create(){ return shared_ptr<ClassA>( new ClassA() ); }

    virtual void quack(){ std::cout<<"quacks like a ClassA Base"<<std::endl; }
};

//~ Wrapper for ClassA
struct WrapClassA : public ClassA, wrapper<WrapClassA>
{

    static shared_ptr<WrapClassA> create(){ return shared_ptr<WrapClassA>( new WrapClassA() ); }

    void quack()
    {
        std::cout<<"quacking like a Wrapper..."<<std::endl;
        if (override f = this->get_override("quack"))
        {
            std::cout<<"... override found!"<<std::endl;
            f();
        }
        else
        {
            std::cout<<"... no override found!"<<std::endl;
            ClassA::quack();
        }
    }

    void default_quack(){ this->ClassA::quack(); }
};

//~ C++ Call Test
void quack( shared_ptr<ClassA> ptr )
{
    ptr->quack();
}

//~ Exposing
BOOST_PYTHON_MODULE(TestCase)
{
    def( "quack", &quack );

    class_<ClassA, shared_ptr<WrapClassA>, noncopyable>( "ClassA", no_init )
        .def( "__init__", make_constructor(&WrapClassA::create) )
        .def( "quack", &ClassA::quack, &WrapClassA::default_quack )
    ;
}

//~ Main
int main()
{

    PyImport_AppendInittab( "TestCase", &initTestCase );
 Py_Initialize();

    boost::python::object main_module((boost::python::handle<>(boost::python::borrowed(PyImport_AddModule("__main__")))));
    boost::python::object main_namespace = main_module.attr("__dict__");

    boost::python::object testcase_module( (boost::python::handle<>(PyImport_ImportModule("TestCase"))) );
    main_namespace["TestCase"] = testcase_module;

    FILE* test_file = fopen("test.py", "r");
    PyRun_SimpleFile(test_file, "test.py");
    fclose( test_file );


    std::cin.get();

 return 0;
}

这是test.py的内容：

print "Testing.."

class Derived( TestCase.ClassA ):
    def __init__( self ):
 TestCase.ClassA.__init__( self )
    def quack( self ):
 print( "Quacks like a derived class!" )


Ainst = TestCase.ClassA()
TestCase.quack( Ainst ) #Should print 'Quacks like ClassA Base'

Dinst = Derived()
TestCase.quack( Dinst ) #Should print 'Quacks like a derived class!', but doesn't!

这是输出结果：

测试中... 像一个包装器一样叫唤... ... 没有找到重写！像一个 ClassA 基类叫唤... ... 没有找到重写！像一个 ClassA 基类

所以基类和从Python派生的类表现得是一样的。看起来出于某种原因，它没有找到重写的部分。我不太确定，但这可能和create()函数有关。有什么想法的话，非常感谢！

编辑：

我在Python脚本中添加了pythonquack - 这次工作正常：

def pythonquack( Inst ):
    print Inst
    Inst.quack()

调用Ainst和Dinst时，输出是'像一个基类叫唤'和'像一个派生类叫唤'，这正是我所期待的。所以出于某种原因，重写的部分没有传回到C++中。

继承重写方法 boost.python 动态绑定 C++与Python交互共享指针静态工厂方法虚函数

Boost::Python、静态工厂和继承

1 个回答

撰写回答