如何安全正确地将 [[T]] 转换为 UnsafePointer <UnsafePointer<T> &gt; 暂时

Question

I need to call C functions that take 2d arrays. The future arrays are created in Swift, and are generally [String] , but I'm interested in the [[T]] case too.

The API I'm calling specifies that its functions always copy data passed to them if necessary, so I don't want create a copy of the contents myself just to pass it in, and I only need to worry about the pointers being valid until I can pass them into the C functions. My current approach is to do

    let addressArray = someArray.map { (array) in
        array.withUnsafeBufferPointer({ (buffer) in
            // get an array of addresses to each individual member
            return buffer.baseAddress
        })
    }

addressArray.withUnsafeBufferPointer { bufferPointer in
     someCFunction(bufferPointer.baseAddress)
     // do something with someArray to attempt to ensure that the pointers are valid past the lifetime of the withUnsafeBufferPointer call
}

This works, but as the pointers returned from withUnsafeBufferPointer are said to only be valid in that scope, it's clearly wrong (though by being certain to always require that someArray remain alive until after I'm done with someCFunction I feel fairly confident that it won't break in the short term). But there must be a better way; what is it?

Answer 1

As you have experienced, your code would seemingly work occasionally. But as you have written, your code is wrong as the returned pointers from withUnsafeBufferPointer is valid only in the scope of its closure parameter.

And I do not understand what you mean it won't break in the short term , but I recommend you never to be confident about undocumented and unclear behaviors.

You may need to create some stable pointers, you can achieve that by allocating the regions explicitly.

I would write something like this when I need UnsafePointer<UnsafePointer<T>> to pass the content of nested Array [[T]] . (Assuming T is a primitive type.)

let bufPtrArray = someArray.map {subArray -> UnsafeMutableBufferPointer<T> in
    let bufPtr = UnsafeMutableBufferPointer<T>.allocate(capacity: subArray.count)
    _ = bufPtr.initialize(from: subArray)
    return bufPtr
}
defer {bufPtrArray.forEach{bufPtr in bufPtr.deallocate()}}

let addressArray = bufPtrArray.map {bufPtr in UnsafePointer(bufPtr.baseAddress!)}

addressArray.withUnsafeBufferPointer { bufferPointer in
    someCFunction(bufferPointer.baseAddress!)
    //...
}

Or, if you do not need codes specified in //... , you can just write:

someCFunction(addressArray)

Answer 2

The problem for me is that all the premises of the question seem false. Swift won't copy anything it doesn't have to, so there isn't necessarily any inefficiency in passing actual values. You can pass a Swift array where a C array is expected. And there isn't really any such thing as a multidimensional C array, so you can just pass a one-dimensional array (suitably arranged, of course).

For example, here's a method that takes an array of int along with information about how big a "row" ( r ) and a "column" ( c ) is to be (code taken from https://www.geeksforgeeks.org/dynamically-allocate-2d-array-c/ ):

- (void) giveMeACArray: (int*) array r: (int) r c: (int) c {
    int i, j, count;
    int *arr[r];
    for (i=0; i<r; i++)
        arr[i] = (int *)malloc(c * sizeof(int));
    count = 0;
    for (i = 0; i <  r; i++)
        for (j = 0; j < c; j++)
            arr[i][j] = ++count;
    // let's test it
    for (i = 0; i <  r; i++)
        for (j = 0; j < c; j++)
            printf("%d ", arr[i][j]);
}

Let's say that's part of the implementation of an Objective-C class called Thing. Okay then, here we are in Swift:

let t = Thing()
var arr : [CInt] = [1,2,3,4,5,6,7,8,9,10,11,12]
t.giveMeACArray(&arr, r: 3, c: 4)

Nothing got copied and the right answer got printed. So I don't see what your buffer pointers are for.