go调用C实现的dll，如何将含有多个字符串和整型数据的复杂结构体从Go传递给C函数，并且C如何通过回调函数返回复杂的结构体给go

要将含有多个字符串和整型数据的复杂结构体从Go传递给C函数，首先需要在Go中定义一个与C结构体相对应的Go结构体，并使用C语言的数据类型（如C.CString）将字符串转换为C字符串。例如：

package main

/*
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int id;
    char *name;
    char *address;
} Person;

void print_person(Person *p) {
    printf("ID: %d\n", p->id);
    printf("Name: %s\n", p->name);
    printf("Address: %s\n", p->address);
}
*/
import "C"
import (
    "unsafe"
)

type Person struct {
    ID      int
    Name    string
    Address string
}

func main() {
    p := Person{
        ID:      1,
        Name:    "John Doe",
        Address: "123 Main St",
    }

    cName := C.CString(p.Name)
    cAddress := C.CString(p.Address)
    defer C.free(unsafe.Pointer(cName))
    defer C.free(unsafe.Pointer(cAddress))

    cPerson := C.Person{
        id:      C.int(p.ID),
        name:    cName,
        address: cAddress,
    }

    C.print_person(&cPerson)
}

在这个例子中，我们首先在Go中定义了一个Person结构体，然后在C中定义了一个相应的Person结构体。我们使用C语言的数据类型将Go中的字符串转换为C字符串，并将Go中的整型数据转换为C中的整型数据。最后，我们将转换后的C结构体传递给C函数print_person。

要让C回调函数返回复杂的结构体给Go，可以使用Go中的CGO特性。首先，在Go中定义一个函数类型作为回调函数的签名。例如：

type Callback func(int, string) Person

然后，在C函数中调用该回调函数并将结果返回给Go。例如：

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int id;
    char *name;
    char *address;
} Person;

typedef Person (*Callback)(int, char *);

Person *get_person(Callback callback) {
    Person *p = malloc(sizeof(Person));
    p->id = 1;
    p->name = "John Doe";
    p->address = "123 Main St";
    (*callback)(p->id, p->name, p->address);
    return p;
}

在这个例子中，我们首先在C中定义了一个函数指针类型Callback作为回调函数的签名，并在get_person函数中使用该回调函数。在回调函数中，我们将结果封装到Person结构体中，并将其返回给Go。

最后，在Go中调用C函数并传递回调函数作为参数。例如：

package main

/*
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int id;
    char *name;
    char *address;
} Person;

typedef Person (*Callback)(int, char *);

Person *get_person(Callback callback) {
    Person *p = malloc(sizeof(Person));
    p->id = 1;
    p->name = "John Doe";
    p->address = "123 Main St";
    (*callback)(p->id, p->name, p->address);
    return p;
}
*/
import "C"

import (
    "fmt"
    "unsafe"
)

type Person struct {
    ID      int
    Name    string
    Address string
}

type Callback func(int, string, string)

func main() {
    callback := Callback(func(id int, name string, address string) {
        p := Person{
            ID:      id,
            Name:    name,
            Address: address,
        }
        fmt.Printf("%+v\n", p)
    })

    cCallback := C.Callback(unsafe.Pointer(&callback))
    C.get_person(cCallback)
}

在这个例子中，我们首先在Go中定义了一个函数类型Callback作为回调函数的签名。然后，在main函数中，我们将该回调函数封装为Callback类型，并使用C语言的数据类型将其转换为C指针类型。最后，我们将该指针传递给C函数get_person，并在回调函数中将结果封装到Person结构体中。