如何用Cython将返回double**/double*的C++函数封装为Python代码？

我刚遇到过类似的问题，本质原因是Cython无法自动把原始的C指针直接映射成Python对象——毕竟Python里没有对应裸指针的原生类型，得我们手动处理数据复制和内存管理才行。下面我一步步给你修正代码，先从double*的例子说起，再扩展到double**的高维矩阵场景。

一、先搞定返回double*的场景 #

核心思路是：不能直接返回C指针，要把指针指向的数据复制到Python原生结构（列表或numpy数组），同时必须手动释放C侧分配的内存，避免泄漏。

1. C++侧代码（fib.hpp、fib.cpp） #

先实现生成数组的函数，同时配套内存释放函数：

// fib.hpp
#ifndef FIB_HPP
#define FIB_HPP

extern "C" {
    // 生成n个元素的斐波那契double数组，返回指针
    double* generate_fib(int n);
    // 释放数组内存
    void free_fib(double* arr);
}

#endif

// fib.cpp
#include "fib.hpp"

double* generate_fib(int n) {
    if (n <= 0) return nullptr;
    double* arr = new double[n];
    arr[0] = 0.0;
    if (n == 1) return arr;
    arr[1] = 1.0;
    for (int i = 2; i < n; ++i) {
        arr[i] = arr[i-1] + arr[i-2];
    }
    return arr;
}

void free_fib(double* arr) {
    delete[] arr;
}

用extern "C"是为了避免C++的名字修饰，让Cython能正确找到函数。

2. Cython声明文件（fib.pxd） #

告诉CythonC++函数的签名：

cdef extern from "fib.hpp":
    double* generate_fib(int n)
    void free_fib(double* arr)

3. Cython实现文件（fib.pyx） #

这里是关键！手动复制数据到Python列表，并用try...finally确保内存释放：

from cpython cimport PyList_New, PyList_SetItem
import cython

cdef extern from "fib.hpp":
    double* generate_fib(int n)
    void free_fib(double* arr)

def py_generate_fib(int n):
    if n <= 0:
        raise ValueError("n must be positive")
    # 调用C++函数获取指针
    cdef double* arr_ptr = generate_fib(n)
    if arr_ptr is NULL:
        raise RuntimeError("Failed to generate array")
    try:
        # 复制数据到Python列表
        cdef list result = []
        for i in range(n):
            result.append(arr_ptr[i])
        # 大数据量推荐用numpy（效率更高）：
        # import numpy as np
        # cdef np.ndarray[double, ndim=1] result = np.empty(n, dtype=np.float64)
        # memcpy(result.data, arr_ptr, n * sizeof(double))
        return result
    finally:
        # 必须释放内存，避免泄漏
        free_fib(arr_ptr)

4. 编译脚本（setup.py） #

指定用C++编译：

from setuptools import setup, Extension
from Cython.Build import cythonize
import numpy as np

ext_modules = [
    Extension(
        "fib",
        sources=["fib.pyx", "fib.cpp"],
        language="c++",
        include_dirs=[np.get_include()],  # 用numpy时需要
    )
]

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

编译测试 #

运行python setup.py build_ext --inplace，然后在Python中测试：

import fib
print(fib.py_generate_fib(5))  # 输出 [0.0, 1.0, 1.0, 2.0, 3.0]

二、扩展到返回double**的高维矩阵场景 #

逻辑和一维数组一致：复制每行数据到嵌套列表（或二维numpy数组），同时释放所有层级的内存。

1. 扩展C++代码 #

修改fib.hpp和fib.cpp，添加矩阵生成和释放函数：

// fib.hpp 新增
double** generate_matrix(int rows, int cols);
void free_matrix(double** mat, int rows);

// fib.cpp 新增
double** generate_matrix(int rows, int cols) {
    if (rows <=0 || cols <=0) return nullptr;
    double** mat = new double*[rows];
    for (int i=0; i<rows; ++i) {
        mat[i] = new double[cols];
        // 填充示例数据：第i行第j列的值为i*cols + j
        for (int j=0; j<cols; ++j) {
            mat[i][j] = static_cast<double>(i*cols + j);
        }
    }
    return mat;
}

void free_matrix(double** mat, int rows) {
    for (int i=0; i<rows; ++i) {
        delete[] mat[i];
    }
    delete[] mat;
}

2. 更新Cython声明和实现 #

更新fib.pxd添加新函数声明：

cdef extern from "fib.hpp":
    double* generate_fib(int n)
    void free_fib(double* arr)
    double** generate_matrix(int rows, int cols)
    void free_matrix(double** mat, int rows)

在fib.pyx中添加矩阵封装函数：

def py_generate_matrix(int rows, int cols):
    if rows <=0 or cols <=0:
        raise ValueError("rows and cols must be positive")
    cdef double** mat_ptr = generate_matrix(rows, cols)
    if mat_ptr is NULL:
        raise RuntimeError("Failed to generate matrix")
    try:
        # 复制到嵌套列表
        cdef list result = []
        for i in range(rows):
            cdef list row = []
            for j in range(cols):
                row.append(mat_ptr[i][j])
            result.append(row)
        # 大数据量推荐用numpy：
        # import numpy as np
        # cdef np.ndarray[double, ndim=2] result = np.empty((rows, cols), dtype=np.float64)
        # for i in range(rows):
        #     memcpy(result[i].data, mat_ptr[i], cols * sizeof(double))
        return result
    finally:
        free_matrix(mat_ptr, rows)

测试二维矩阵 #

编译后测试：

import fib
print(fib.py_generate_matrix(2,3))  # 输出 [[0.0,1.0,2.0], [3.0,4.0,5.0]]

三、错误原因解析 #

你遇到的Cannot convert 'double *' to python object错误，本质是：
Python的对象都带有引用计数和类型信息，而C的裸指针只是一个内存地址——Cython不知道这个指针指向的是单个值、数组还是其他结构，也不知道内存由谁管理，因此没有内置的转换规则。必须我们手动把指针指向的数据复制到Python原生类型，同时负责释放C侧分配的内存。

关键注意事项 #

1. 内存管理：C++中new分配的内存必须用delete/delete[]释放，一定要用try...finally确保内存被释放，避免泄漏。
2. 效率选择：小数据量用Python列表足够，大数据量优先用numpy数组，memcpy的复制效率远高于循环。
3. 类型安全：在Cython中尽量用cdef声明变量类型，避免隐式转换带来的问题。

内容的提问来源于stack exchange，提问作者G.P.