Python与C/C++交互问题：调用方法遇访问冲突及回调需求

Hey there! Let's tackle these two common headaches when working with C/C++ and Python interop—access violations when calling Python from C/C++, and setting up callbacks from your C/C++ extension to Python functions. I'll break each down with explanations and actionable fixes.

问题1：从C/C++调用Python方法时触发访问违例异常 #

Access violations (segfaults) here almost always boil down to issues with Python's runtime state or memory management. Let's go through the most likely culprits and fixes:

• Forgot to initialize the Python runtime properly
  If your C/C++ program is embedding Python, you need to initialize the interpreter before any Python calls. Skipping this leads to invalid memory access when you try to interact with Python objects.
  Example initialization code:

  #include <Python.h>
  
  int main() {
      // Initialize Python runtime
      Py_Initialize();
  
      // Your code to call Python methods goes here...
  
      // Cleanup
      Py_Finalize();
      return 0;
  }
  

• Not handling the Global Interpreter Lock (GIL)
  Python uses the GIL to manage thread-safe access to its objects. If your C/C++ code runs without acquiring the GIL, accessing Python objects will cause crashes. Always wrap Python calls with GIL acquisition/release:

  // Acquire the GIL
  PyGILState_STATE gil_state = PyGILState_Ensure();
  
  // Call Python functions/methods here...
  
  // Release the GIL
  PyGILState_Release(gil_state);
  

• Invalid or dangling Python object references
  When passing a Python object (like your MyClass instance) to C/C++, you must manage its reference count. If Python deallocates the object before your C/C++ code uses it, you'll hit an access violation. Use Py_INCREF to keep the object alive, and Py_DECREF when done to avoid leaks:

  extern "C" void callFunc(PyObject* obj) {
      // Increment reference count
      Py_INCREF(obj);
  
      // Acquire GIL
      PyGILState_STATE gil_state = PyGILState_Ensure();
  
      // Get and call the "func" method
      PyObject* method = PyObject_GetAttrString(obj, "func");
      if (method && PyCallable_Check(method)) {
          PyObject_CallObject(method, NULL);
      }
  
      // Cleanup
      Py_XDECREF(method);
      PyGILState_Release(gil_state);
      Py_DECREF(obj);
  }
  

• Mismatched data types in ctypes
  Double-check that your Python argtypes match the C/C++ function signature. Your code sets mDll.callFunc.argtypes = [ctypes.py_object]—this is correct if your C function takes a PyObject*, but a type mismatch here will cause memory corruption.

问题2：在Python中调用C/C++扩展，需在该扩展内回调Python脚本中的函数 #

Your Python code is already set up correctly to pass the MyClass instance to the C DLL. The key is implementing the callFunc function in C/C++ to safely invoke the func method on the passed object. Here's how to do it right:

Step 1: C/C++ DLL Implementation #

#include <Python.h>

// Use extern "C" to avoid C++ name mangling
extern "C" __declspec(dllexport) void callFunc(PyObject* py_obj) {
    // 1. Acquire the GIL first—critical for thread safety
    PyGILState_STATE gil_state = PyGILState_Ensure();

    // 2. Verify the object has a callable "func" method
    PyObject* func_method = PyObject_GetAttrString(py_obj, "func");
    if (!func_method) {
        PyErr_Print(); // Print Python errors to console
        PyGILState_Release(gil_state);
        return;
    }

    if (!PyCallable_Check(func_method)) {
        PyErr_SetString(PyExc_TypeError, "The 'func' attribute is not callable");
        PyErr_Print();
        Py_DECREF(func_method);
        PyGILState_Release(gil_state);
        return;
    }

    // 3. Call the method (no arguments, so pass NULL)
    PyObject* result = PyObject_CallObject(func_method, NULL);
    if (result == NULL) {
        PyErr_Print();
    } else {
        Py_DECREF(result); // Clean up the result object
    }

    // 4. Cleanup all references
    Py_DECREF(func_method);
    PyGILState_Release(gil_state);
}

Step 2: Robustness Tweaks for Your Python Code #

Your existing code is solid, but add these checks to avoid silent failures:

# -*- coding: UTF-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
import ctypes

class MyClass:
    def func(self):
        print "func"
        open("out.txt","w").write("func")
        print "func2"
        return

# Add DLL load error handling
try:
    mDll = ctypes.CDLL("xx.dll", ctypes.RTLD_GLOBAL)
except OSError as e:
    print(f"Failed to load DLL: {e}")
    sys.exit(1)

c = MyClass()
mDll.callFunc.argtypes = [ctypes.py_object]
mDll.callFunc(c)

Why This Works #

• We acquire the GIL to ensure safe access to Python's runtime.
• We explicitly validate the func method exists and is callable to avoid unexpected crashes.
• We manage reference counts properly to prevent memory leaks.
• We handle errors with PyErr_Print to get meaningful debug output if something goes wrong.

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