将a [] float32转换为C * float

Question

我想将一个slice [] float32的第一个元素的指针传递给一个C变量，但不知何故我无法弄清楚。

C代码：

typedef struct 
{ const float *data_in ; 
    float *data_out ; 

} SRC_DATA ; 

转到：

mySlice := make([]float32, 20) 
foo := C.SRC_DATA{} 
foo.data_in = *C.float(&mySlice[0]) // here the program breaks 

据我明白，应该是可以直接将指针传递到所述第一元件在切片从转到C ，而不使用unsafe.Pointer（）。然后C函数将迭代切片（已知长度）。

任何提示感谢！

Answer 1

1. 需要使用C.float类型的切片，而不是float32：

package main 
/* 
#include <stdio.h> 
void test(float *in) { 
    printf("C %f %f\n", in[0], in[1]); 
} 
*/ 
import "C" 

func main() { 
    in := []C.float{1.23, 4.56} 
    C.test(&in[0]) // C 1.230000 4.560000 
} 

转到不允许将转至指针存储在围棋分配结构传递给CGO：

package main 
/* 
#include <stdio.h> 
typedef struct { 
     float *in; 
     float *out; 
} SRC_DATA; 

void test(SRC_DATA *data) { 
    printf("C %f %f\n", data->in[0], data->in[1]); 
    data->out[0] = 8.8; 
    data->out[1] = 9.9; 
} 
*/ 
import "C" 
import "fmt" 

func main() { 
    in := []C.float{1.23, 4.56} 
    out := make([]C.float, 2) 
    data := &C.SRC_DATA{in: &in[0], out: &out[0]} 
    C.test(data) // panic: runtime error: cgo argument has Go pointer to Go pointer 
    fmt.Println("Go", out) 
} 

但是你可以创建在C辅助函数：

package main 
/* 
#include <stdio.h> 
typedef struct { 
     float *in; 
     float *out; 
} SRC_DATA; 

void test(SRC_DATA *data) { 
    printf("C %f %f\n", data->in[0], data->in[1]); 
    data->out[0] = 8.8; 
    data->out[1] = 9.9; 
} 

void test_helper(float *in, float *out) { 
    SRC_DATA data; 
    data.in = in; 
    data.out = out; 
    test(&data); 
} 
*/ 
import "C" 
import "fmt" 

func main() { 
    in := []C.float{1.23, 4.56} 
    out := make([]C.float, 2) 
    C.test_helper(&in[0], &out[0]) // C 1.230000 4.560000 
    fmt.Println("Go", out) // Go [8.8 9.9] 
} 

或者你可以在C分配和释放SRC_DATA结构：

package main 
/* 
#include <stdio.h> 
#include <stdlib.h> 
typedef struct { 
     float *in; 
     float *out; 
} SRC_DATA; 

void test(SRC_DATA *data) { 
    printf("C %f %f\n", data->in[0], data->in[1]); 
    data->out[0] = 8.8; 
    data->out[1] = 9.9; 
} 

SRC_DATA *alloc_src_data() { 
    return (SRC_DATA*)malloc(sizeof(SRC_DATA)); 
} 

void free_src_data(SRC_DATA *p) { 
    free(p); 
} 
*/ 
import "C" 
import "fmt" 


func main() { 
    in := []C.float{1.23, 4.56} 
    out := make([]C.float, 2) 
    data := C.alloc_src_data() 
    defer C.free_src_data(data) 
    data.in = &in[0] 
    data.out = &out[0] 
    C.test(data) // C 1.230000 4.560000 
    fmt.Println("Go", out) // Go [8.8 9.9] 
}