Ich möchte in C ++ geschriebenen Code zu einer Bibliothek machen, die in Python aufgerufen werden kann. Es gab jedoch eine große Mauer namens Cython.
Dies ist ein "Cython" -Tutorial, das Python explosiv macht: Übergeben Sie ein C ++ - Klassenobjekt an ein Klassenobjekt auf der Python-Seite. Es ist eine Fortsetzung davon ①.
Der Code ist unter "github hier" aufgeführt. Schauen Sie also bitte vorbei.
Letztes Mal habe ich erklärt, dass beim Konvertieren einer in C ++ geschriebenen Bibliothek nach Cython, damit sie von Python aus verwendet werden kann, der in C ++ deklarierte Typ an die Python-Seite übergeben wird.
Es stellte sich heraus, dass wenn Sie int oder double selbst oder einen Vektor übergeben, der sie als Elemente enthält, dieser auf der Python-Seite in einen geeigneten Typ konvertiert wird.
Dieses Mal werde ich erklären, wie Sie ein Objekt einer von Ihnen in C ++ - Code definierten Klasse an die Python-Seite zurückgeben.
Ich habe eine neue `TestClass2``` wie diese zum Testen erstellt. Die Konfiguration ist so, dass TestClass1``` das Objekt TestClass2``` als Eigenschaft hat. Um diese Eigenschaft zu erhalten, bereiten Sie einen Konstruktor vor, der `` getter und` `setter, TestClass2, empfängt.
cpp_library/TestClass2.h
namespace my_library
{
class TestClass2{
private:
int property_int;
public:
TestClass2(){};
};
} // namespace my_library
cpp_library/TestClass2.cpp
cpp_library/TestClass1.h
#pragma once
#include <gmp.h>
#include <vector>
#include "TestClass2.h"
using namespace std;
namespace my_library
{
class TestClass1{
private:
TestClass2 property_test_class2;
public:
//Kürzung
TestClass1(TestClass2 test_class2);
TestClass2 get_property_test_class2();
};
} // namespace my_library
cpp_library/TestClass1.cpp
//Kürzung
TestClass1::TestClass1(){
this->property_test_class2 = TestClass2();
}
TestClass1::TestClass1(TestClass2 test_class2){
this->property_test_class2 = test_class2;
}
TestClass2 TestClass1::get_property_test_class2(){
return this->property_test_class2;
}
void TestClass1::set_property_test_class2(TestClass2 test_class2){
this->property_test_class2 = test_class2;
}
Die Implementierung sieht so aus.
testclass2cython Ist
testclass2Es ist eine Wrapper-Klasse zum Übergeben an Python entsprechend.
cython/test_class2.pxd
cdef extern from "../cpp_library/TestClass2.h" namespace "my_library":
cdef cppclass TestClass2:
TestClass2()
cython/test_class2.pyx
cdef class TestClass2Cython:
cdef TestClass2* ptr
def __cinit__(self):
self.ptr = new TestClass2()
def __deadaloc(self):
del self.ptr
cython/test_class1.pxd
from libcpp.vector cimport vector
from libcpp.string cimport string
from test_class2 cimport *
cdef extern from "../cpp_library/TestClass1.h" namespace "my_library":
cdef cppclass TestClass1:
TestClass1()
TestClass1(TestClass2 test_class2)
void test_function1()
void gmp_print_test()
int test_sum(int x, int y)
double test_sum_double(double x, double y)
vector[int] test_vector_int(vector[int] x, int y)
void set_property_test_class2(TestClass2 test_class2)
TestClass2 get_property_test_class2()
Das Wichtigste hier ist
--Deklarieren Sie das Klassenobjekt auf der C ++ - Seite als `` `cdef TestClass2 cpp_test_class2``` und
`test_class2 = TestClass2Cython ()`.Hier wird `test_class2.ptr``` in test_class2.pyx als` cdef TestClass2 * ptr``` definiert, und `self.ptr [0]` ist ein C ++ - Klassenobjekt. Bedeutet die Substanz von.
Da `get_property_test_class2 ()` auf der C ++ - Seite die Substanz des Klassenobjekts von TestClass2 zurückgab, musste es als self.ptr [0] festgelegt werden.
cython/test_class2.pyx
def get_property_test_class2(self):
cdef:
TestClass2 cpp_test_class2
test_class2 = TestClass2Cython()
cpp_test_class2 = self.ptr.get_property_test_class2()
test_class2.ptr[0] = cpp_test_class2
return test_class2
Wie üblich nach dem Kompilieren mit `` `python setup.py install```
(myenv) root@e96f489c2395:/from_local# python
Python 3.6.3 (default, Jan 30 2020, 06:37:54)
[GCC 7.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import my_library
>>> test = my_library.test()
>>> test.get_property_test_class2()
<my_library.TestClass2Cython object at 0x7f776003d240>
Es kann bestätigt werden, dass die `TestClass2``` von der C ++ - Seite an die` `TestClass2Cython übergeben wird und von der Python-Seite erkannt werden kann.
Für die auf der C ++ - Seite definierten Objekte der Klasse wurde festgestellt, dass die empfangende Klasse auf der Cython-Seite definiert und der Rückgabewert der Funktion in diesen Typ konvertiert und zurückgegeben werden muss.
Es ist natürlich, das zu sagen, aber es ist überraschend schwierig, also hoffe ich, dass es hilft.
Als nächstes möchte ich erklären, wie ein Klassenobjekt auf der Python-Seite entgegen dieser Zeit über Cython an C ++ übergeben wird.
Diesmal hier.
Ende.
Recommended Posts