这里的主要问题是流程中有两个不同的运行时，Ruby 和 Go，而且它们都不像其他人那样在内部进行探索。因此，为了从 Ruby 调用 Go，您必须首先从 Ruby 中获取数据，然后进入 Go，然后从 Go 中获取结果，然后再进入 Ruby。实际上，您必须通过 C 从 Ruby 转到 Go，即使没有实际的 C 代码。
从 Go 端开始，假设您要使用的函数具有这样的签名：
func TheFunc(in []string) []string
您可以将其导出到您的共享库中，这将给出以下 C 签名：
extern GoSlice TheFunc(GoSlice p0);
GoSlice 在哪里
typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
虽然这可能有效，但它提供了对 Go 数据的直接访问，尤其是返回值，因此并不安全。
一个解决方案是提供一个包装函数，它接受一个指向 C 字符串数组的指针（即**char）和数组的长度。然后该函数可以解包这些数据并将其转换为 Go 数组（或切片）并将其传递给执行该工作的真正函数。这个包装函数还需要一种获取结果的方法。一种方法是传入一个指向字符串数组的指针（即***char），函数可以分配数组，用结果字符串填充它，并将其地址写入该指针指向的位置。
这种解决方案的缺点是在 Go 中分配内存并依赖调用代码来释放它。
这有点乱，但看起来像这样：
// #include <stdlib.h>
import "C"
import "unsafe"
//export CTheFunc
func CTheFunc(in **C.char, len C.int, out ***C.char) {
inSlice := make([]string, int(len))
// We need to do some pointer arithmetic.
start := unsafe.Pointer(in)
pointerSize := unsafe.Sizeof(in)
for i := 0; i< int(len); i++ {
// Copy each input string into a Go string and add it to the slice.
pointer := (**C.char)(unsafe.Pointer(uintptr(start) + uintptr(i)*pointerSize))
inSlice[i] = C.GoString(*pointer)
}
// Call the real function.
resultSlice := TheFunc(inSlice)
// Allocate an array for the string pointers.
outArray := (C.malloc(C.ulong(len) * C.ulong(pointerSize)))
// Make the output variable point to this array.
*out = (**C.char)(outArray)
// Note this is assuming the input and output arrays are the same size.
for i := 0; i< int(len); i++ {
// Find where to store the address of the next string.
pointer := (**C.char)(unsafe.Pointer(uintptr(outArray) + uintptr(i)*pointerSize))
// Copy each output string to a C string, and add it to the array.
// C.CString uses malloc to allocate memory.
*pointer = C.CString(resultSlice[i])
}
}
这提供了一个具有以下签名的 C 函数，我们可以使用 FFI 从 Ruby 访问该函数。
extern void CDouble(char** p0, int p1, char*** p2);
Ruby 方面非常相似，但相反。我们需要将数据复制到 C 数组中，并分配一些内存，我们可以传递地址来接收结果，然后将数组、其长度和输出指针传递给 Go 函数。当它返回时，我们需要将 C 数据复制回 Ruby 字符串和数组并释放内存。它可能看起来像这样：
require 'ffi'
# We need this to be able to use free to tidy up.
class CLib
extend FFI::Library
ffi_lib FFI::Library::LIBC
attach_function :free, [:pointer], :void
end
class GoCaller
extend FFI::Library
ffi_lib "myamazinggolibrary.so"
POINTER_SIZE = FFI.type_size(:pointer)
attach_function :CTheFunc, [:pointer, :int, :pointer], :void
# Wrapper method that prepares the data and calls the Go function.
def self.the_func(ary)
# Allocate a buffer to hold the input pointers.
in_ptr = FFI::MemoryPointer.new(:pointer, ary.length)
# Copy the input strings to C strings, and write the pointers to in_ptr.
in_ptr.write_array_of_pointer(ary.map {|s| FFI::MemoryPointer.from_string(s)})
# Allocate some memory to receive the address of the output array.
out_var = FFI::MemoryPointer.new(:pointer)
# Call the actual function.
CTheFunc(in_ptr, ary.length, out_var)
# Follow the pointer in out_var, and convert to an array of Ruby strings.
# This is the return value.
out_var.read_pointer.get_array_of_string(0, ary.length)
ensure
# Free the memory allocated in the Go code. We don’t need to free
# the memory in the MemoryPointers, it is done automatically.
out_var.read_pointer.get_array_of_pointer(0, ary.length).each {|p| CLib.free(p)}
CLib.free(out_var.read_pointer)
end
end
这确实涉及在每个方向复制数据两次，从（或到）Ruby 中，然后到（或从）Go 中，但我认为如果没有运行时（尤其是垃圾收集器）相互绊倒。可以将数据直接存储在某个共享区域并对其进行操作，而无需使用 Ruby 中的 FFI::Pointers 和 Go 中的 unsafe 进行复制，但这首先会破坏使用这些语言的目的。