Kann jemand eine Möglichkeit vorschlagen, um c ++ - Objekte mit Cython zu manipulieren, wenn die c ++ - Instanz einer Klasse den Konstruktor einer anderen umschlossenen Klasse wie unten beschrieben speisen soll?

Beachten Sie den Hinweis in der Pyx-Datei für die Klasse PySession, die ein PyConfigParams-Objekt als Argument verwendet und dann Werte daraus extrahieren muss, um ein c ++ ConfigParams-Objekt zu erstellen. Das ConfigParams-Objekt wird dann verwendet, um den Konstruktor von Session zu versorgen.

Es wäre ideal, eine Prozedur zu haben, mit der ich das vom PyConfigParams-Objekt umschlossene ConfigParams-C ++ - Objekt direkt in den Konstruktor von Session "einschleusen" kann, ohne es zuerst zerlegen und dann ein neues C ++ - Objekt erstellen zu müssen, um den Konstruktor zu versorgen. Das funktioniert natürlich. Es ist jedoch eine umständliche und brutale Art, diese Lösung zu implementieren, ganz zu schweigen von der Unzuverlässigkeit.

Ich kenne PyCapsule, es kann jedoch erforderlich sein, die c ++ - Header zu berühren, was ich nicht tun kann.

Diesbezüglich stellt sich jedoch eine andere Frage: Was ist, wenn ich eine umschlossene Klasse (sagen wir hier PySession) benötige, um das Verhalten der C ++ - API durch Zurückgeben einer ConfigParams-Instanz zu simulieren? Muss ich das C ++ - Objekt umkehren und demontieren, um ein Python-PyConfigParams zu erstellen, das dann an den Python-Benutzer in der Python-Welt zurückgegeben wird? Anregungen sind sehr willkommen! Vielen Dank!

Nehmen wir an, ich habe zwei c ++ - Klassen namens ConfigParams und Session. Eine Instanz von ConfigParams wird verwendet, um den Konstruktor der Session-Klasse zu versorgen:

C ++ KlassenConfigParams-Klasse

<code>// ConfigParams.h
#include <iostream> 
using namespace std; 
class ConfigParams 
{ 
  int parameter1; 
 public: 
  ConfigParams(int par1) { this->parameter1 = par1;} 
  int getPar1() { return this->parameter1; } 
};
</code>

Session-Klasse

<code>// Session.h 
#include <iostream> 
using namespace std; 
#include "configparams.h" 
class Session 
{ 
  int sessionX; 
 public: 
  Session(ConfigParams parameters) { this->sessionX = parameters.getPar1(); } 
  void doSomething(); 
}; 

void Session::doSomething() 
{ 
  cout << "Session parameters set as: " << endl; 
  cout << "X = " << this->sessionX << endl; 
} 
</code>

Cython Pyx- und PXD-Dateien für die oben genannten Klassen:PyConfigParams

<code># configparams.pxd 
cdef extern from "configparams.h": 
    cppclass ConfigParams: 
        ConfigParams(int par1) 
        int getPar1() 

# configparams.pyx 
cdef class PyConfigParams: 
    cdef ConfigParams* thisptr 
    def __cinit__(self, i): 
        self.thisptr = new ConfigParams(<int> i) 
    def getPar1(self): 
        return self.thisptr.getPar1() 
</code>

PySession-Klasse

<code># session.pxd 
from configparams cimport * 
cdef extern from "session.h": 
    cdef cppclass Session: 
        Session(ConfigParams parameters) 
        void doSomething() 

# session.pyx
cdef class PySession: 
    cdef Session* thisptr 
    def __cinit__(self, pars): 
        # Note that here I have to extract the values 
        # from the pars (python PyConfigParams object) 
        # in order to build a c++ ConfigParams object 
        # which feeds the c ++ constructor of Session. 
        cdef ConfigParams* cpppargsptr = new ConfigParams(<int> pars.getPar1()) 
        self.thisptr = new Session(cpppargsptr[0]) 
    def doSomething(self): 
        self.thisptr.doSomething() 
</code>