如何在Swift中向C API传递结构体数组？

原C API定义 #

typedef struct Datapoints {
  double *ptr;
  uintptr_t len;
} Datapoints;

double my_function(const struct Datapoints *baseline_data,
                   uint32_t baseline_data_len,
                   const struct Datapoints *new_data);

核心问题 #

调用该API时遇到两个关键问题：

1. 第一个参数是Datapoints结构体的指针数组，第三个参数是单个Datapoints结构体指针；
2. 原Swift代码中，尝试存储withUnsafeMutableBufferPointer闭包内的指针供后续使用，但这类指针仅在闭包执行期间有效，超出范围后会失效；同时多层闭包嵌套写法繁琐。

原Swift尝试代码 #

var baseline_datapoints = [Datapoints]()
var current_datapoints:Datapoints = Datapoints()

// 此循环用于构建包含Datapoints结构体指针的baseline_datapoints数组
for reading in baseline {
    let datapoints:[Double] = reading.datapoints

    // 不可行：传递给body的指针仅在withUnsafeMutableBufferPointer(_:)执行期间有效，不可存储或返回供后续使用
    // 但我们正尝试存储它供后续使用 🤷🏻

    datapoints.withUnsafeMutableBufferPointer{ ptr in
        baseline_datapoints.append(Datapoints(ptr: ptr.baseAddress, len: UInt(datapoints.count)) )
    }
}

self.newData.withUnsafeMutableBufferPointer {ptr in
    current_datapoints = Datapoints(ptr: ptr.baseAddress, len: UInt(self.newData.count))
}

let x = baseline_datapoints.withUnsafeBufferPointer{
    (baselineptr: UnsafeBufferPointer<Datapoints>) -> Double in
    return withUnsafePointer(to: current_datapoints) {
        (current_ptr: UnsafePointer<Datapoints>) -> Double in

        return my_function(baseline_ptr.baseAddress, UInt32(baseline_datapoints.count ), current_ptr)
    }
}

解决方案 #

1. 解决指针有效期问题：使用持久化内存 #

Swift数组的内存会因扩容、重分配等操作失效，因此需要为每个Datapoints的ptr分配独立的持久化内存，并持有内存所有权避免被提前释放：

// 持有内存块的所有权，防止内存被提前释放
var baselineMemoryStorage: [UnsafeMutableBufferPointer<Double>] = []
var baselineDatapoints = [Datapoints]()

// 构建基线数据数组
for reading in baseline {
    let sourceData = reading.datapoints
    // 分配对应容量的内存
    let buffer = UnsafeMutableBufferPointer<Double>.allocate(capacity: sourceData.count)
    // 将Swift数组的数据拷贝到分配的内存中
    _ = buffer.initialize(from: sourceData)
    // 保存内存块引用，避免被释放
    baselineMemoryStorage.append(buffer)
    // 构建Datapoints结构体并加入数组
    baselineDatapoints.append(Datapoints(ptr: buffer.baseAddress, len: UInt(sourceData.count)))
}

// 调用API
let result = baselineDatapoints.withUnsafeBufferPointer { baselinePtr in
    self.newData.withUnsafeBufferPointer { newDataPtr in
        let newDatapoint = Datapoints(ptr: newDataPtr.baseAddress, len: UInt(self.newData.count))
        // 适配原API的指针参数版本
        return withUnsafePointer(to: newDatapoint) { newPtr in
            my_function(baselinePtr.baseAddress, UInt32(baselineDatapoints.count), newPtr)
        }
    }
}

// 调用完成后手动释放内存，避免泄漏
for buffer in baselineMemoryStorage {
    buffer.deinitialize(count: buffer.count)
    buffer.deallocate()
}

2. 针对修改后的API简化实现 #

你后续将API修改为第三个参数按值传递：

double my_function(const struct Datapoints *baseline_data,
                   uint32_t baseline_data_len,
                   const struct Datapoints new_data);

此时可以去掉嵌套的withUnsafePointer，直接传递结构体值：

// （内存分配部分同上述代码）

let result = baselineDatapoints.withUnsafeBufferPointer { baselinePtr in
    self.newData.withUnsafeBufferPointer { newDataPtr in
        let newDatapoint = Datapoints(ptr: newDataPtr.baseAddress, len: UInt(self.newData.count))
        // 直接传递结构体值，无需指针转换
        return my_function(baselinePtr.baseAddress, UInt32(baselineDatapoints.count), newDatapoint)
    }
}

// （内存释放部分同上述代码）

关键说明 #

• 必须持有分配的内存引用：baselineMemoryStorage用来保存每个内存块的指针，确保在API调用期间内存不会被Swift的自动释放机制回收；
• 手动管理内存：调用完成后必须释放分配的内存，避免内存泄漏；
• 简化闭包嵌套：将API调用逻辑合并到一个闭包链中，避免存储临时指针，确保指针仅在有效范围内使用。

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