Python3.5+Cython：字符串列表转char**传C++函数遇编译问题

Let's break down your problems one by one and fix them step by step. I've dealt with similar char** conversion issues in Cython on ARM64 systems before, so here's what's going wrong and how to resolve it:

Problem 1: "PyString_AsString未声明" Compile Error #

The root cause here is Python version compatibility. PyString_AsString is a Python 2 API function—if you're using Python 3 (the default on Ubuntu 16.04 even though it's an older release), this function no longer exists (it was replaced by PyUnicode_AsUTF8 for Unicode strings). Even if you found it in cpython/string.pxd, Cython only exposes it when targeting Python 2.

Fix for This Issue: #

Choose one of these options based on your Python version:

• If you must use Python 2, add language_level=2 to your Cython build: either via a comment in your .pyx file (# cython: language_level=2) or in your setup.py configuration.
• For Python 3 (recommended), switch to using Python 3's native string-to-bytes handling instead of relying on deprecated Python 2 APIs, as shown in the complete solution below.

Problem 2: "Storing unsafe C derivative of temporary Python reference" #

This error triggers because when you encode a Python string to bytes and immediately take its char* pointer, the temporary bytes object isn't referenced anywhere. Python's garbage collector could clean it up while your C++ function is still using the pointer, leading to undefined behavior. Cython catches this unsafe pattern and warns you.

Fix for This Issue: #

You need to keep a reference to the bytes/string objects for the entire duration of the C++ function call. We'll use a "keep-alive" list to hold these objects, preventing them from being garbage collected early.

Complete Working Solution #

Here's a safe, Python 3-compatible implementation to convert a Python list of strings to char** for your C++ function, tailored to your ARM64 Ubuntu 16.04 environment:

1. Updated cy_wrapper.pyx Code #

# cython: language_level=3  # Explicitly target Python 3
from cpython.list cimport PyList_GetItem, PyList_Size
from cpython.bytes cimport PyBytes_AsString
from cpython.object cimport PyObject
from libc.stdlib cimport malloc, free

# Declare your C++ function (adjust names and headers to match your actual code)
cdef extern from "your_cpp_header.h" namespace "your_namespace":
    void your_cpp_function(char** str_array, int str_count)

cdef char** py_str_list_to_charpp(list py_strings, list keep_alive):
    """Convert a Python list of strings to a C char**, with references kept alive to avoid GC issues."""
    cdef int list_length = PyList_Size(py_strings)
    cdef char** c_str_array = <char**>malloc(list_length * sizeof(char*))
    
    if not c_str_array:
        raise MemoryError("Failed to allocate memory for char** array")
    
    for i in range(list_length):
        cdef PyObject* py_str_obj = PyList_GetItem(py_strings, i)
        # Encode Python string to UTF-8 bytes (handles Unicode correctly)
        cdef bytes py_bytes = py_str_obj.encode('utf-8')
        # Add the bytes object to keep_alive to prevent garbage collection
        keep_alive.append(py_bytes)
        # Get the safe C pointer from the bytes object
        c_str_array[i] = PyBytes_AsString(py_bytes)
    
    return c_str_array

def call_cpp(list input_strings):
    """Python-facing function to invoke your C++ code."""
    cdef list keep_alive = []
    cdef char** c_strs = py_str_list_to_charpp(input_strings, keep_alive)
    
    try:
        # Call your C++ function with the char** array and list length
        your_cpp_function(c_strs, len(input_strings))
    finally:
        # Free the allocated char** array (critical to avoid memory leaks)
        free(c_strs)
        # keep_alive will be automatically cleaned up by Python when this function exits

2. Updated setup.py Code #

Ensure your build config properly handles C++ compilation for ARM64:

from setuptools import setup, Extension
from Cython.Build import cythonize

ext_modules = [
    Extension(
        "cy_wrapper",
        sources=["cy_wrapper.pyx", "your_cpp_source.cpp"],  # Add your C++ source file here
        language="c++",
        extra_compile_args=["-std=c++11", "-O2"],  # Ubuntu 16.04's GCC 5.4 supports C++11
        extra_link_args=["-std=c++11"],
    )
]

setup(
    name="cy_wrapper",
    ext_modules=cythonize(ext_modules),
)

Key Notes for Your ARM64/Tegra Ubuntu 16.04 Environment: #

• Ubuntu 16.04's default GCC is 5.4, which supports C++11 but not newer standards—stick with -std=c++11 unless you've manually upgraded your compiler.
• If your C++ function takes const char** instead of char**, adjust the Cython declaration and conversion accordingly (add const to the char** type in both the extern block and conversion function).
• Test with a small input list first to verify no memory leaks or crashes.

Why This Works: #

• The keep_alive list holds onto the encoded bytes objects, so Python can't garbage collect them while the C++ function is running.
• We use Python 3's native bytes handling instead of deprecated Python 2 APIs, eliminating the PyString_AsString compile error.
• The try/finally block ensures we always free the allocated char** array, preventing memory leaks.

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