Cython / Python / C ++-繼承：將派生類作為參數傳遞給需要基類的函數

Question

我正在使用Cython包裝一組C ++類，並允許它們使用Python接口。 下面提供了示例代碼：

BaseClass.h：

#ifndef __BaseClass__
#define __BaseClass__
#include <stdio.h>
#include <stdlib.h>
#include <string>
using namespace std;
class BaseClass
{
    public:
        BaseClass(){};
        virtual ~BaseClass(){};
        virtual void SetName(string name){printf("in base set name\n");}
        virtual float Evaluate(float time){printf("in base Evaluate\n");return 0;}
        virtual bool DataExists(){printf("in base data exists\n");return false;}
};
#endif /* defined(__BaseClass__) */

DerivedClass.h：

#ifndef __DerivedClass__
#define __DerivedClass__

#include "BaseClass.h"

class DerivedClass:public BaseClass
{
    public:
        DerivedClass(){};
        virtual ~DerivedClass(){};
        virtual float Evaluate(float time){printf("in derived Evaluate\n");return 1;}
        virtual bool DataExists(){printf("in derived data exists\n");return true;}
        virtual void MyFunction(){printf("in my function\n");}
        virtual void SetObject(BaseClass *input){printf("in set object\n");}
};
#endif /* defined(__DerivedClass__) */

NextDerivedClass.h：

#ifndef __NextDerivedClass__
#define __NextDerivedClass__

#include "DerivedClass.h"

class NextDerivedClass:public DerivedClass
{
    public:
        NextDerivedClass(){};
        virtual ~NextDerivedClass(){};
        virtual void SetObject(BaseClass *input){printf("in set object of next derived class\n");}
};
#endif /* defined(__NextDerivedClass__) */

InheritTest.pyx：

cdef extern from "BaseClass.h":
cdef cppclass BaseClass:
    BaseClass() except +
    void SetName(string)
    float Evaluate(float)
    bool DataExists()

cdef extern from "DerivedClass.h":
    cdef cppclass DerivedClass(BaseClass):
        DerivedClass() except +
        void MyFunction()
        float Evaluate(float)
        bool DataExists()
        void SetObject(BaseClass *)

cdef extern from "NextDerivedClass.h":
    cdef cppclass NextDerivedClass(DerivedClass):
        NextDerivedClass() except +
        # ***  The issue is right here ***
        void SetObject(BaseClass *)

cdef class PyBaseClass:
    cdef BaseClass *thisptr
    def __cinit__(self):
        if type(self) is PyBaseClass:
            self.thisptr = new BaseClass()
    def __dealloc__(self):
        if type(self) is PyBaseClass:
            del self.thisptr

cdef class PyDerivedClass(PyBaseClass):
    cdef DerivedClass *derivedptr
    def __cinit__(self):
        self.derivedptr = self.thisptr = new DerivedClass()
    def __dealloc__(self):
        del self.derivedptr
    # def Evaluate(self, time):
    #     return self.derivedptr.Evaluate(time)
    def SetObject(self, PyBaseClass inputObject):
         self.derivedptr.SetObject(<BaseClass *>inputObject.thisptr)

cdef class PyNextDerivedClass(PyDerivedClass):
    cdef NextDerivedClass *nextDerivedptr
    def __cinit__(self):
        self.nextDerivedptr = self.thisptr = new NextDerivedClass()
    def __dealloc__(self):
        del self.nextDerivedptr
    def SetObject(self, PyBaseClass input):
        self.nextDerivedptr.SetObject(<BaseClass *>input.thisptr)

我希望能夠在Python中調用SetObject，如下所示：

main.py：

from inheritTest import PyBaseClass as base
from inheritTest import PyDerivedClass as der
from inheritTest import PyNextDerivedClass as nextDer

#This works now!
a = der()
b = der()
a.SetObject(b)

#This doesn't work -- keeping the function declaration causes a overloaded error, not keeping it means the call below works, but it calls the inherited implementation (From derived class)
c = nextDer()
c.SetObject(b)

我認為這是可行的，因為這些類是相互繼承的，但是它給了我以下錯誤：

在函數定義中未指定類型會使它認為inputObject是純Python對象（它沒有基於C的屬性），在這種情況下，錯誤是：

對此的一種怪異解決方法是，使具有不同名稱的Python函數需要不同類型的參數（例如：SetObjectWithBase，SetObjectWithDerived），然后在其實現中，調用相同的基於C的函數，將輸入類型轉換為類型。 我知道這是可行的，但我想避免這樣做。 即使有辦法我可以在函數中捕獲類型錯誤，並在內部進行處理，我認為也可以，但我不確定如何實現。

希望這個問題有意義，如果您需要其他信息，請告訴我。

**** EDIT **** ：已對代碼進行了編輯，以使基本繼承有效。 經過更多的研究之后，我意識到該問題是在多個繼承級別上發生的，例如，請參見上面的編輯代碼。 基本上，保留NextDerivedClass的SetObject的聲明會導致“模棱兩可的重載方法”錯誤，不保留它會使我調用對象上的函數，而是調用繼承的實現（來自DerivedClass）。 **

Answer 1

經過下面的答案和實驗的大量幫助之后，我認為我了解在Cython中實現基本繼承的工作方式，我在回答自己的問題以驗證/增進我的理解，並希望能對以后的任何人有所幫助可能會遇到相關問題。 如果該說明有任何問題，請隨時在下面的評論中對我進行糾正，我將對其進行編輯。 我不認為這是唯一的方法，因此我敢肯定其他方法也可以，但是這對我來說是有效的。

概述/經驗教訓：

因此，基本上，根據我的理解，Cython足夠聰明（只要有適當的信息）就可以遍歷繼承樹/樹，並根據要調用的對象的類型來調用虛擬函數的適當實現。

重要的是要嘗試鏡像要包裹在.pyx文件中的C ++繼承結構。 這意味着確保：

1）導入的C ++ / Cython cpp類（從聲明為cdef extern from ）彼此繼承，其方式與實際C ++類相同

2）對於每個導入的類，僅聲明唯一的方法/成員變量（對於在兩個類中實現方式不同的虛擬函數， BaseClass和DerivedClass都不應具有函數聲明）。 只要一個繼承自另一個，函數聲明只需要在Base導入的類中。

3）Python包裝器類（即PyBaseClass / PyDerivedClass ）也應該以與實際C ++類相同的方式相互繼承

4）與上述類似，虛擬函數的接口僅需要存在於PyBase包裝類中（不應同時放入兩個類中，在實際運行代碼時將調用正確的實現）。

5）對於每個從其繼承或繼承的Python包裝器類，您需要一個if type(self) is class-name:檢入__cinit__()和__dealloc__()函數。 這樣可以防止出現段錯誤等。您不需要在樹狀樹中檢查“葉節點”（不會繼承或子類化的類）

6）確保在__dealloc__()函數中，僅刪除當前指針（而不刪除任何繼承的指針）

7）同樣，在__cinit__() ，對於繼承的類，請確保設置了當前指針以及指向您要創建的類型的對象的所有派生指針（即*self.nextDerivedptr = self.derivedptr = self.thisptr = new NextDerivedClass()* ）

希望以上幾點在您看到下面的代碼時很有道理，可以根據我的需要/打算使其運行並編譯和運行。

BaseClass.h：

#ifndef __BaseClass__
#define __BaseClass__

#include <stdio.h>
#include <stdlib.h>
#include <string>

using namespace std;

class BaseClass
{
    public:
        BaseClass(){};
        virtual ~BaseClass(){};
        virtual void SetName(string name){printf("BASE: in set name\n");}
        virtual float Evaluate(float time){printf("BASE: in Evaluate\n");return 0;}
        virtual bool DataExists(){printf("BASE: in data exists\n");return false;}
};
#endif /* defined(__BaseClass__) */ 

DerivedClass.h：

#ifndef __DerivedClass__
#define __DerivedClass__

#include "BaseClass.h"
#include "string.h"

using namespace std;

class DerivedClass:public BaseClass
{
    public:
        DerivedClass(){};
        virtual ~DerivedClass(){};
        virtual void SetName(string name){printf("DERIVED CLASS: in Set name \n");}
        virtual float Evaluate(float time){printf("DERIVED CLASS: in Evaluate\n");return 1.0;}
        virtual bool DataExists(){printf("DERIVED CLASS:in data exists\n");return true;}
        virtual void MyFunction(){printf("DERIVED CLASS: in my function\n");}
        virtual void SetObject(BaseClass *input){printf("DERIVED CLASS: in set object\n");}
};
#endif /* defined(__DerivedClass__) */

NextDerivedClass.h：

    #ifndef __NextDerivedClass__
    #define __NextDerivedClass__

    #include "DerivedClass.h"

    class NextDerivedClass:public DerivedClass
    {
        public:
            NextDerivedClass(){};
            virtual ~NextDerivedClass(){};
            virtual void SetObject(BaseClass *input){printf("NEXT DERIVED CLASS: in set object\n");}
            virtual bool DataExists(){printf("NEXT DERIVED CLASS: in data exists \n");return true;}
    };
    #endif /* defined(__NextDerivedClass__) */

InheritTest.pyx：

#Necessary Compilation Options
#distutils: language = c++
#distutils: extra_compile_args = ["-std=c++11", "-g"]

#Import necessary modules
from libcpp cimport bool
from libcpp.string cimport string
from libcpp.map cimport map
from libcpp.pair cimport pair
from libcpp.vector cimport vector

cdef extern from "BaseClass.h":
    cdef cppclass BaseClass:
        BaseClass() except +
        void SetName(string)
        float Evaluate(float)
        bool DataExists()

cdef extern from "DerivedClass.h":
    cdef cppclass DerivedClass(BaseClass):
        DerivedClass() except +
        void MyFunction()
        void SetObject(BaseClass *)

cdef extern from "NextDerivedClass.h":
    cdef cppclass NextDerivedClass(DerivedClass):
        NextDerivedClass() except +

cdef class PyBaseClass:
    cdef BaseClass *thisptr
    def __cinit__(self):
        if type(self) is PyBaseClass:
            self.thisptr = new BaseClass()
    def __dealloc__(self):
        if type(self) is PyBaseClass:
            del self.thisptr
    def SetName(self, name):
        self.thisptr.SetName(name)
    def Evaluate(self, time):
        return self.thisptr.Evaluate(time)
    def DataExists(self):
        return self.thisptr.DataExists()

cdef class PyDerivedClass(PyBaseClass):
    cdef DerivedClass *derivedptr
    def __cinit__(self):
        if type(self) is PyDerivedClass:
            self.derivedptr = self.thisptr = new DerivedClass()
    def __dealloc__(self):
        if type(self) is PyBaseClass:
            del self.derivedptr
    def SetObject(self, PyBaseClass inputObject):
        self.derivedptr.SetObject(<BaseClass *>inputObject.thisptr)
    def MyFunction(self):
        self.derivedptr.MyFunction()

cdef class PyNextDerivedClass(PyDerivedClass):
    cdef NextDerivedClass *nextDerivedptr
    def __cinit__(self):
        self.nextDerivedptr = self.derivedptr = self.thisptr = new NextDerivedClass()
    def __dealloc__(self):
        del self.nextDerivedptr

test.py：

from inheritTest import PyBaseClass as base
from inheritTest import PyDerivedClass as der
from inheritTest import PyNextDerivedClass as nextDer

a = der()
b = der()
a.SetObject(b)
c = nextDer()
a.SetObject(c)
c.DataExists()
c.SetObject(b)
c.Evaluate(0.3)


baseSig = base()
signal = der()
baseSig.SetName('test')
signal.SetName('testingone')
baseSig.Evaluate(0.3)
signal.Evaluate(0.5)
signal.SetObject(b)
baseSig.DataExists()
signal.DataExists()

請注意，當我打電話時：

c = nextDer()
c.Evaluate(0.3)

Cython的工作方式是從繼承樹中查找“評估”的“最新”實現。 如果它存在於NextDerivedClass.h ，它將調用它（我已經嘗試過並且可以工作），因為它不存在，所以它向上了一步並檢查DerivedClass 。 該函數在此處實現，因此輸出為：

>> DERIVED CLASS: in Evaluate

希望以后對某人有幫助，如果我的理解有誤，或者只是語法/語法錯誤，請在下面發表評論，我將嘗試解決這些問題。 再次感謝在下面回答的人，這是他們的回答的摘要，目的只是為了幫助驗證我的理解。 謝謝！

Answer 2

您編寫的代碼無法編譯。 我懷疑您真正的PyDerivedClass並不是真正從PyBaseClass派生的，就好像最后一行是

(<DerivedClass*>self.thisptr).SetObject(inputObject.thisptr)

這也可以解釋您遇到的類型錯誤，這是我無法重現的錯誤。

Answer 3

老實說，這看起來像個錯誤。 您傳遞的對象是所需類的實例，但是它仍然會引發錯誤。 您可能希望將其顯示在cython用戶郵件列表中，以便主要開發人員可以查看它。

一個可能的解決方法是定義一個代表兩種參數類型的融合類型 ，並在方法內部使用它。 不過，這似乎有點過分。