将 C++ 抽象类作为参数传递给 Cython

Question

如果我有一个抽象基类和一个继承自它的派生类，但我有另一个类将抽象基类对象作为参数，我应该如何包装它？

class A {
 public:
  A(int x, int y);
  virtual int FooA(int x, int y) = 0;
  virtual void FooB() = 0;

}

class B : public A{
  B(int x, int y, int z, int w);
  int FooA(int x, int y);
  void FooB();
  void FooC(int z, int w);
}

class C {
 public:
  C(A* ptr, int p);

}

我应该如何将它包装成一个整体？我知道我不应该包装抽象类 A 但我在包装 C 时遇到了困难，因为我没有 A 的 python 对象

编辑：实际上我设法包装了课程，但我仍然遇到错误，我将进一步说明。

源文件

cdef extern from "A.h"
   cdef cppclass A:
      A(int x, int y)
      int FooA(int x, int y)
      void FooB()  

cdef extern from "B.h"
   cdef cppclass B(A):  
      B(int x, int y, int z, int w)
      int FooA(int x, int y)
      void FooB()
      void FooC(int z, int w)  

cdef extern from "C.h"
   cdef cppclass C:
      C(A* ptr, int p)

cdef class pyA:
   cdef A* baseptr
   def __cinit__(self, int x, int y):
      if type(self) is A:
          self.baseptr = new A(int x, int y)

   def __dealloc__(self):
      if type(self) is A:
          del self.baseptr

   def FooA(self, int x, int y):
      pass

   def FooB(self):
      pass

cdef class pyB(pyA):
   def __cinit__(self, int x, int y, int z, int w):
      if type(self) is pyB:
         self.derivedptr = self.baseptr = new B(int x, int y, int z, int w) 
   def __dealloc__(self):
      del self.derivedptr 

   def FooC(self, int z, int w):
      self.derivedptr.FooC(int z, int w)

cdef class pyC:
   cdef C *thisptr
   def __cinit__(self, pyA ptr, int p):
      self.thisptr(<A *> ptr.thisptr, int p)
   def __dealloc__(self):
      del self.thisptr

这是在我测试 pyC 并将 pyB 作为第一个参数传递时编译的，我得到：

TypeError: "Expected pyA, got pyB". 

pyB 不应该也可以作为第一个参数传递，因为它是 pyA 的子类吗？还是我离题了？

Answer 1

我的回答晚了。但对于那些可能感兴趣的人，这里是工作代码。

啊

#ifndef A_H_
#define A_H_

class A {
public:
  virtual int FooA(int x, int y) = 0;
  virtual void FooB() = 0;
};

#endif /* A_H_ */

乙

#ifndef B_H_
#define B_H_

#include "A.h"

class B : public A{
public:
  B(int x, int y, int z, int w);
  int FooA(int x, int y);
  void FooB();
  void FooC(int z, int w);
};

#endif /* B_H_ */

通道

#ifndef C_H_
#define C_H_

#include "A.h"

class C {
 public:
  C(A* ptr, int p);
};

#endif /* C_H_ */

B.cpp

#include "B.h"
#include <iostream>

using namespace std;

B::B(int x, int y, int z, int w)
{
    cout << "B::B" << endl;
    cout << x << " " << y << " "
         << z << " " << w << endl;
}

int B::FooA(int x, int y)
{
    cout << "B::FooA" << endl;
    cout << x << " " << y << endl;
    return 0;
}

void B::FooB()
{
    cout << "B::FooB" << endl;
}

void B::FooC(int z, int w)
{
    cout << "B::FooC" << endl;
    cout << z << " " << w << endl;
}

cpp

#include "C.h"
#include <iostream>

using namespace std;

C::C(A* ptr, int p)
{
    cout << "C::C" << endl;
    cout << ptr->FooA(0,1) << endl;
    ptr->FooB();
}

源文件

# distutils: language = c++
# distutils: sources = [B.cpp, C.cpp]

cdef extern from "A.h":
   cdef cppclass A:
      A(int x, int y) except +
      int FooA(int x, int y)
      void FooB()  

cdef extern from "B.h":
   cdef cppclass B(A):  
      B(int x, int y, int z, int w) except +
      int FooA(int x, int y)
      void FooB()
      void FooC(int z, int w)  

cdef extern from "C.h":
   cdef cppclass C:
      C(A *ptr, int p) except +

cdef class pyA:
   cdef A *baseptr
   def __cinit__(self):
      pass

   def FooA(self, int x, int y):
      pass

   def FooB(self):
      pass

cdef class pyB(pyA):
   cdef B *derivedptr
   def __cinit__(self, int x, int y, int z, int w):
     self.derivedptr = new B(x, y, z, w)
     self.baseptr = self.derivedptr

   def __dealloc__(self):
      del self.derivedptr 

   def FooC(self, int z, int w):
      self.derivedptr.FooC(z, w)

cdef class pyC:
   cdef C *thisptr
   def __cinit__(self, pyA ptr, int p):
      self.thisptr = new C(ptr.baseptr, p)

   def __dealloc__(self):
      del self.thisptr

设置文件

from distutils.core import setup
from Cython.Build import cythonize

setup(
    name = 'testapp',
    ext_modules = cythonize('*.pyx'),
)

最后编译

$python setup.py build_ext --inplace