Question

观察者模式经常出现在我的C ++项目中，我现在希望通过Cython绑定向Python解释器公开。我试图构建一个说明情况的最小例子。 Spectacle接受从抽象基类Observer派生的任何对象，例如Onlooker。当我们致电Spectacle::event()时，会通知每个注册观察员。

这是文件ObserverPattern.h的内容：

class Spectacle {
private:
    std::vector<Observer*> observers;
public:

    Spectacle() {};
    virtual ~Spectacle() {};

    virtual void registerObserver(Observer* observer) {
        this->observers.push_back(observer);
    }

    virtual void event() {
        std::cout << "event triggered" << std::endl;
        for (Observer* observer : this->observers) {
            observer->onEvent();
        }
    }
};

class Observer {
public:
    Observer() {};
    virtual ~Observer() {};
    virtual void onEvent() = 0;

};

class Onlooker : public Observer {
public:
    Onlooker() {};
    virtual ~Onlooker() {};
    virtual void onEvent() {
        std::cout << "event observed" << std::endl;
    }
};

这是我的.pyx文件的内容，其中包含绑定：

    cdef extern from "ObserverPattern.h":
        cdef cppclass _Spectacle "Spectacle":
            _Spectacle() except +
            void registerObserver(_Observer* observer)
            void event()

    cdef extern from "ObserverPattern.h":
        cdef cppclass _Observer "Observer":
            _Observer() except +
            void onEvent()

    cdef extern from "ObserverPattern.h":
        cdef cppclass _Onlooker "Onlooker":
            _Onlooker() except +
            void onEvent()

    cdef class Spectacle:
        cdef _Spectacle _this

        def event(self):
            self._this.event()

        def registerObserver(self, Observer observer):
            self._this.registerObserver(observer._this)

   cdef class Observer:
        cdef _Observer* _this   # must be a pointer because _Observer has pure virtual method

    cdef class Onlooker(Observer):
        pass   # what should be the class body?

这会编译，但在调用event()并通知观察者时会发生段错误：

>>> spec = CythonMinimal.Spectacle()
>>> look = CythonMinimal.Onlooker()
>>> spec.registerObserver(look)
>>> spec.event()
event triggered
Segmentation fault: 11

这里的问题是什么，修复怎么样？

Answer 1

您的问题基本上是“在Python中实现C ++接口”。

唯一可行的方法是编写一个实际的C ++类这将回调到Python。

Cython有未记录的experimental_cpp_class_def选项允许使用Cython语法创建C ++类。它不漂亮（IMO），但它的工作原理对于许多场景。

以下是如何实现代表所提供的Observer的方法 Python可调用：

from cpython.ref cimport PyObject, Py_INCREF, Py_DECREF

cdef cppclass ObserverImpl(_Observer):
    PyObject* callback

    __init__(object callback):  # constructor. "this" argument is implicit.
        Py_INCREF(callback)
        this.callback = <PyObject*>callback

    __dealloc__():  # destructor
        Py_DECREF(<object>this.callback)

    void onEvent():
        (<object>this.callback)()  # exceptions will be ignored

这就是你如何使用它：

def registerObserver(self, callback not None):  # user passes any Python callable
    self._this.registerObserver(new ObserverImpl(callback))

C ++对象，就像C结构一样，不能保存Cython管理的object 引用。这就是为什么你必须使用PyObject*字段和管理参考算你自己。当然，你可以使用内部方法强制转换并使用任何Cython功能。

另一个棘手的时刻是异常传播。在C ++中定义的onEvent()方法不能传播Python异常。 Cython将简单地忽略它无法传播的异常。如果你想做得更好，自己抓住它们并存放在某个地方以便以后检查或重新抛出为C ++异常。（我认为在Cython语法中抛出C ++异常是不可能的，但你可以调用外部抛出辅助函数。）

如果您的观察者有多个方法，那么callback将是一个Python类，而不是直接调用它，您可以调用它的方法，如(<object>this.callback).onEvent()。

显然，ObserverImpl也可以直接用C ++编码。 Py_INCREF，Py_DECREF和PyObject_Call / PyObject_CallMethod是唯一必需的Python API。

用Cython包装观察者模式

1 个答案: