Passing C++ abstract class as argument to Cython

Question

If I have an abstract base class and a derived class that inherits from it but I have another class that takes the abstract base class object as an argument, how should I go about wrapping it?

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);

}

How should I go about wrapping this as a whole? I know that I am not supposed to wrap the abstract class A but I am having difficulties wrapping C since I do not have the python object for A

EDIT: Actually I managed to wrap the class but I am still getting errors which I will illustrate further.

source.pyx

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

This compiled by when I was testing pyC and passing pyB as the first argument, I got:

TypeError: "Expected pyA, got pyB".

Shouldn't pyB be able to be passed as the first argument as well since it is a subclass of pyA? Or am I way off?

You can probably get rid of the remaining error by removing the `PyA` type specifier from `PyC.__cinit__`. [Also change the cast to `` to allow for the possibility that it might be the wrong type] — DavidW, Mar 19 '15 at 08:22

score 5 · Answer 1 · answered Jun 22 '15 at 06:09

My answer is late. But for those who might be interested, here is the working code.

A.h

#ifndef A_H_
#define A_H_

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

#endif /* A_H_ */

B.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_ */

C.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;
}

C.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();
}

source.pyx

# 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

setup.py

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

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

Finally, compile

$python setup.py build_ext --inplace

Passing C++ abstract class as argument to Cython

1 Answers1