如何仅使用C/Python API将C++成员函数绑定到Python？

Absolutely! You can bind C++ member functions using pure CPython API without altering their original signatures—you just need thin wrapper functions that bridge the CPython calling convention to your C++ code. This keeps things lightweight and avoids heavy libraries like Boost.Python. Here's how to do it:

Core Idea: Wrapper Functions + C++ Object Storage #

The key is to:

• Store a pointer to your C++ object inside the corresponding Python class instance.
• Write small wrapper functions that follow the PyCFunction signature (PyObject* (*)(PyObject*, PyObject*)), extract the C++ object from the Python self parameter, call the C++ member function, and handle return values (if any) for Python.

Step-by-Step Implementation Example #

Let's use your Position class as a reference.

1. Define a Python Instance Struct for Your C++ Class #

First, create a struct that extends PyObject to hold a pointer to your C++ object:

#include <Python.h>

// Your original C++ class
class Position {
    int x;
    int y;
public:
    Position() : x(0), y(0) {}
    ~Position() {}
    void SetZero() { x = 0; y = 0; }
    int GetX() const { return x; }
    int GetY() const { return y; }
};

// Python instance struct that wraps the C++ Position
typedef struct {
    PyObject_HEAD
    Position* cpp_instance; // Pointer to the underlying C++ object
} PyPosition;

2. Write Wrapper Functions for C++ Member Functions #

These wrappers adhere to the PyCFunction signature, but internally call your C++ member functions:

// Wrapper for Position::SetZero()
PyObject* PyPosition_SetZero(PyObject* self, PyObject* args) {
    // Cast self to our custom PyPosition struct
    PyPosition* py_pos = reinterpret_cast<PyPosition*>(self);
    // Call the C++ member function
    py_pos->cpp_instance->SetZero();
    // Return Py_None for void functions (remember to increment its refcount)
    Py_RETURN_NONE;
}

// Wrapper for Position::GetX()
PyObject* PyPosition_GetX(PyObject* self, PyObject* args) {
    PyPosition* py_pos = reinterpret_cast<PyPosition*>(self);
    int x = py_pos->cpp_instance->GetX();
    // Convert C++ int to Python int object
    return PyLong_FromLong(x);
}

// Wrapper for Position::GetY()
PyObject* PyPosition_GetY(PyObject* self, PyObject* args) {
    PyPosition* py_pos = reinterpret_cast<PyPosition*>(self);
    int y = py_pos->cpp_instance->GetY();
    return PyLong_FromLong(y);
}

3. Define Method Definitions for Python #

Create a PyMethodDef array to map Python method names to your wrappers:

PyMethodDef PyPosition_Methods[] = {
    {"set_zero", PyPosition_SetZero, METH_NOARGS, "Set position coordinates to (0, 0)"},
    {"get_x", PyPosition_GetX, METH_NOARGS, "Get the X coordinate"},
    {"get_y", PyPosition_GetY, METH_NOARGS, "Get the Y coordinate"},
    {NULL, NULL, 0, NULL} // Sentinel to mark the end of the array
};

4. Define the Python Type Object #

This ties together your struct, methods, and lifecycle management (creation/destruction of C++ objects):

PyTypeObject PyPosition_Type = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "my_module.Position", // Python class name (module.Class)
    .tp_basicsize = sizeof(PyPosition), // Size of our instance struct
    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    .tp_doc = "A 2D position coordinate class", // Docstring
    .tp_methods = PyPosition_Methods, // Link to our method definitions
    .tp_init = (initproc)PyPosition_Init, // Constructor handler
    .tp_dealloc = (destructor)PyPosition_Dealloc // Destructor handler
};

5. Implement Lifecycle Handlers #

Manage the creation and destruction of your C++ objects when Python instances are created/deleted:

// Python constructor handler: create a new C++ Position
int PyPosition_Init(PyObject* self, PyObject* args, PyObject* kwds) {
    PyPosition* py_pos = reinterpret_cast<PyPosition*>(self);
    py_pos->cpp_instance = new Position();
    return 0; // Return 0 on success
}

// Python destructor handler: clean up the C++ Position
void PyPosition_Dealloc(PyObject* self) {
    PyPosition* py_pos = reinterpret_cast<PyPosition*>(self);
    delete py_pos->cpp_instance;
    // Call the base type deallocator
    Py_TYPE(self)->tp_free(self);
}

6. Register the Class with Your Module #

Finally, add the Position class to your Python module definition:

static PyModuleDef MyModule_Def = {
    PyModuleDef_HEAD_INIT,
    .m_name = "my_module", // Module name in Python
    .m_doc = "Module wrapping C++ Position class", // Module docstring
    .m_size = -1 // -1 means the module doesn't have state
};

PyMODINIT_FUNC PyInit_my_module(void) {
    PyObject* module;
    // Prepare the Position type for use
    if (PyType_Ready(&PyPosition_Type) < 0)
        return NULL;
    // Create the module
    module = PyModule_Create(&MyModule_Def);
    if (!module)
        return NULL;
    // Add the Position class to the module
    Py_INCREF(&PyPosition_Type);
    PyModule_AddObject(module, "Position", (PyObject*)&PyPosition_Type);
    return module;
}

Simplify Wrapper Code with Macros #

If you have many member functions, you can use macros to avoid writing repetitive wrapper code. For example, for void functions with no arguments:

#define WRAP_VOID_NOARGS(py_func_name, cpp_func) \
PyObject* py_func_name(PyObject* self, PyObject* args) { \
    PyPosition* py_pos = reinterpret_cast<PyPosition*>(self); \
    py_pos->cpp_instance->cpp_func(); \
    Py_RETURN_NONE; \
}

// Usage: generates the PyPosition_SetZero wrapper automatically
WRAP_VOID_NOARGS(PyPosition_SetZero, SetZero)

You can create similar macros for functions with parameters or return values to cut down on boilerplate.

Key Notes #

• No changes to original C++ code: You never modify your C++ class or its member functions—all adaptation happens in the wrapper layer.
• Lightweight: This uses only the core CPython API, no external dependencies.
• Scalable: Macros let you handle large numbers of classes/methods with minimal repetitive code.

内容的提问来源于stack exchange，提问作者HelloWorld