我需要使用Python C API将C ++类公开到嵌入式python中。
换句话说是这样的： Exposing a C++ class instance to a python embedded interpreter 但根本没有使用Boost。
我想要放入的应用程序已经很老了，编译器，环境等......无法处理Boost。
答案 0 :(得分：5)
简而言之，只要您了解C ++和Python之间的差异，并且让C ++和Python都能处理语言之间的差异，您想要做的并不是很困难。我发现最简单和最安全的方法是使用Python ctypes为C ++类定义Python类包装器，并定义--extern“C” - 将C ++类桥接到Python类的包装器。
这种方法的优点是Python可以处理所有内存管理，引用计数等...;而C ++可以处理所有的类型转换和错误处理。此外，如果Python C API将来有任何更改，您也不必担心它。相反，您可以专注于重要的代码。
与在Python C API中包装C ++类相比，这样更方便！除此之外，此方法不需要C ++或Python标准库中未包含的任何内容。
下面你会发现一个主要来自其他Stack Overflow帖子的任意示例（在Python包装器中引用）。我在试图弄清楚如何连接Python和C ++时创建的。代码中充斥着有关如何实现代码的每个部分的详细信息。这是一种方法。
Python Wrapper：
"""
My C++ & Python ctypes test class. The following Stack Overflow URLs
either answered my questions as I figured this out, inspired code ideas,
or where just downright informative. However there are were other useful
pages here and there that I did not record links for.
http://stackoverflow.com/questions/1615813/how-to-use-c-classes-with-ctypes
http://stackoverflow.com/questions/17244756/python-ctypes-wraping-c-class-with-operators
http://stackoverflow.com/questions/19198872/how-do-i-return-objects-from-a-c-function-with-ctypes
"""
# Define imports.
from ctypes import cdll, c_int, c_void_p, c_char_p
# Load the shared library.
lib = cdll.LoadLibrary("MyClass.dll")
# Explicitly define the return types and argument types.
# This helps both clarity and troubleshooting. Note that
# a 'c_void_p' is passed in the place of the C++ object.
# The object passed by the void pointer will be handled in
# the C++ code itself.
#
# Each one of the below calls is a C function call contained
# within the external shared library.
lib.createClass.restype = c_void_p
lib.deleteClass.argtypes = [c_void_p]
lib.callAdd.argtypes = [c_void_p, c_void_p]
lib.callAdd.restype = c_int
lib.callGetID.argtypes = [c_void_p]
lib.callGetID.restype = c_char_p
lib.callGetValue.argtypes = [c_void_p]
lib.callGetValue.restype = c_int
lib.callSetID.argtypes = [c_void_p, c_char_p]
lib.callSetID.restype = c_int
lib.callSetValue.argtypes = [c_void_p, c_int]
lib.callSetValue.restype = c_int
class MyClass(object):
"""A Python class which wraps around a C++ object.
The Python class will handle the memory management
of the C++ object.
Not that only the default constructor is called for
the C++ object within the __init__ method. Once the
object is defined any specific values for the object
are set through library function calls.
"""
def __init__(self, id_str = ""):
"""Initialize the C++ class using the default constructor.
Python strings must be converted to a string of bytes.
'UTF-8' is used to specify the encoding of the bytes to
preserve any Unicode characters. NOTE: this can make
for unintended side effects in the C++ code.
"""
self.obj = lib.createClass()
if id_str != "":
lib.callSetID(self.obj, bytes(id_str, 'UTF-8'))
def __del__(self):
"""Allow Python to call the C++ object's destructor."""
return lib.deleteClass(self.obj)
def add(self, other):
"""Call the C++ object method 'add' to return a new
instance of MyClass; self.add(other).
"""
r = MyClass()
lib.callAdd(self.obj, other.obj, r.obj)
return r
def getID(self):
"""Return the C++ object's ID.
C char string also must be converted to Python strings.
'UTF-8' is the specified format for conversion to
preserve any Unicode characters.
"""
return str(lib.callGetID(self.obj), 'utf-8')
def getValue(self):
"""Return the C++ object's Value."""
return lib.callGetValue(self.obj)
def setID(self, id_str):
"""Set the C++ object's ID string.
Remember that Python string must be converted to
C style char strings.
"""
return lib.callSetID(self.obj, bytes(id_str, 'utf-8'))
def setValue(self, n):
"""Set the C++ object's value."""
return lib.callSetValue(self.obj, n)
if __name__ == "__main__":
x = MyClass("id_a")
y = MyClass("id_b")
z = x.add(y)
z.setID("id_c")
print("x.getID = {0}".format(x.getID()))
print("x.getValue = {0}".format(x.getValue()))
print()
print("y.getID = {0}".format(y.getID()))
print("y.getValue = {0}".format(y.getValue()))
print()
print("z.getID = {0}".format(z.getID()))
print("z.getValue = {0}".format(z.getValue()))
C ++课程＆amp; extern C wrapper：
#include <iostream>
#include <new>
#include <string>
using namespace std;
// Manually compile with:
// g++ -O0 -g3 -Wall -c -fmessage-length=0 -o MyClass.o MyClass.cpp
// g++ -shared -o MyClass.dll "MyClass.o"
// Check to see if the platform is a Windows OS. Note that
// _WIN32 applies to both a 32 bit or 64 bit environment.
// So there is no need to check for _WIN64.
#ifdef _WIN32
// On Windows platforms declare any functions meant to be
// called from an external program in order to allow the
// function to be able to be called. Else define a DEF
// file to allow the correct behaviour. (much harder!)
#define DLLEXPORT __declspec(dllexport)
#endif
#ifndef DLLEXPORT
#define DLLEXPORT
#endif
class MyClass {
// A C++ class solely used to define an object to test
// Python ctypes compatibility. In reality this would
// most likely be implemented as a wrapper around
// another C++ object to define the right a compatible
// object between C++ and Python.
public:
MyClass() : val(42), id("1234567890") {};
// Notice the next constructor is never called.
MyClass(string str) : val(42), id(str) {};
~MyClass(){};
int add(const MyClass* b, MyClass* c) {
// Do not allow exceptions to be thrown. Instead catch
// them and tell Python about them, using some sort of
// error code convention, shared between the C++ code
// and the Python code.
try {
c->val = val + b->val;
return 0;
/*
} catch(ExceptionName e) {
// Return a specific integer to identify
// a specific exception was thrown.
return -99
*/
} catch(...) {
// Return an error code to identify if
// an unknown exception was thrown.
return -1;
} // end try
}; // end method
string getID() { return id; };
int getValue() { return val; };
void setID(string str) { id = str; };
void setValue(int n) { val = n; };
private:
int val;
string id;
}; // end class
extern "C" {
// All function calls that Python makes need to be made to
// "C" code in order to avoid C++ name mangling. A side
// effect of this is that overloaded C++ constructors must
// use a separate function call for each constructor that
// is to be used. Alternatively a single constructor can
// be used instead, and then setters can be used to specify
// any of an object instance specific values. Which is
// what was implemented here.
DLLEXPORT void * createClass(void) {
// Inside of function call C++ code can still be used.
return new(std::nothrow) MyClass;
} // end function
DLLEXPORT void deleteClass (void *ptr) {
delete static_cast<MyClass *>(ptr);
} // end function
DLLEXPORT int callAdd(void *a, void *b, void *c) {
// Do not allow exceptions to be thrown. Instead catch
// them and tell Python about them.
try {
MyClass * x = static_cast<MyClass *>(a);
MyClass * y = static_cast<MyClass *>(b);
MyClass * z = static_cast<MyClass *>(c);
return x->add(y, z);
/*
} catch(ExceptionName e) {
// Return a specific integer to identify
// a specific exception was thrown.
return -99
*/
} catch(...) {
// Return an error code to identify if
// an unknown exception was thrown.
return -1;
} // end try
} // end function
DLLEXPORT const char* callGetID(void *ptr) {
try {
MyClass * ref = static_cast<MyClass *>(ptr);
// Inside of function call C++ code can still be used.
string temp = ref->getID();
// A string must be converted to it "C" equivalent.
return temp.c_str();
} catch(...) {
// Return an error code to identify if
// an unknown exception was thrown.
return "-1";
} // end try
} // end function
DLLEXPORT int callGetValue(void *ptr) {
try {
MyClass * ref = static_cast<MyClass *>(ptr);
return ref->getValue();
} catch(...) {
// Return an error code to identify if
// an unknown exception was thrown.
return -1;
} // end try
} // end function
DLLEXPORT int callSetID(void *ptr, char *str) {
try {
MyClass * ref = static_cast<MyClass *>(ptr);
ref->setID(str);
return 0;
} catch(...) {
// Return an error code to identify if
// an unknown exception was thrown.
return -1;
} // end try
} // end function
DLLEXPORT int callSetValue(void *ptr, int n) {
try {
MyClass * ref = static_cast<MyClass *>(ptr);
ref->setValue(n);
return 0;
} catch(...) {
// Return an error code to identify if
// an unknown exception was thrown.
return -1;
} // end try
} // end function
} // end extern
注意：很遗憾，Trog还没有足够的声誉来发表评论，因为我是Stack Overflow的新手。否则，我想首先询问您的嵌入式Python环境中是否有Python ctypes。实际上这是我的第一篇文章。
答案 1 :(得分：0)