Go 语言通过内置的 cgo 工具提供了与 C 语言代码交互的能力。这使得开发者可以利用现有的 C 库，或者在 Go 程序中编写高性能的 C 代码片段。要启用 cgo，只需在 Go 源文件中导入特殊的伪包 "C"。所有在 import "C" 语句前注释块中的 C 代码都将被 cgo 编译并与 Go 代码链接。
示例：Go 调用 C 函数
首先，我们创建一个 C 语言文件 mylib.h 和 mylib.c：
// mylib.h #ifndef MYLIB_H #define MYLIB_H char* Test(); void PrintMessage(char* msg); #endif
// mylib.c
#include "mylib.h"
#include <stdio.h>
#include <stdlib.h> // For malloc/free
char* Test() {
// 注意：这里的字符串字面量存储在只读内存区，不应被 Go 释放
// 如果需要 Go 释放，C 侧应使用 malloc 分配
char* msg = "Hello from C, Go!";
return msg;
}
void PrintMessage(char* msg) {
printf("C says: %s\n", msg);
}然后，在 Go 文件中调用 C 函数：
// main.go
package main
/*
#include "mylib.h"
#include <stdlib.h> // For C.free
*/
import "C"
import (
"fmt"
"unsafe"
)
func main() {
// 调用 C 函数 Test()，它返回一个 char*
cMsg := C.Test()
// 将 C char* 转换为 Go string
goMsg := C.GoString(cMsg)
fmt.Printf("Go received from C: %s\n", goMsg)
// 将 Go string 转换为 C char*
goSendMsg := "Hello C, from Go!"
cSendMsg := C.CString(goSendMsg)
// 调用 C 函数 PrintMessage()
C.PrintMessage(cSendMsg)
// 释放 C 字符串占用的内存，这是 C.CString 分配的
C.free(unsafe.Pointer(cSendMsg))
}编译运行：go run main.go mylib.c
Go 和 C 之间的数据类型转换是 cgo 互操作的关键。cgo 提供了一些内置的转换函数，同时对于复杂类型，需要借助 unsafe 包进行手动转换。
大多数 C 语言的基本数据类型（如 int, char, float, double 等）在 Go 中都有直接或近似的对应关系，并且 cgo 会自动处理这些转换。
| C 类型 | Go 类型 | 备注 |
|---|---|---|
| char | C.char | 通常对应 byte 或 int8 |
| short | C.short | 对应 int16 |
| int | C.int | 对应 int32 |
| long | C.long | 对应 int32 或 int64 (取决于平台) |
| long long | C.longlong | 对应 int64 |
| float | C.float | 对应 float32 |
| double | C.double | 对应 float64 |
| void* | unsafe.Pointer | 泛型指针 |
| const char* | *C.char | 字符串指针 |
示例：基本类型传递
package main
/*
#include <stdio.h>
int add(int a, int b) {
return a + b;
}
double multiply(double x, double y) {
return x * y;
}
*/
import "C"
import "fmt"
func main() {
// Go int 传递给 C int
sum := C.add(C.int(10), C.int(20))
fmt.Printf("C add result: %d\n", sum) // Output: C add result: 30
// Go float64 传递给 C double
product := C.multiply(C.double(3.14), C.double(2.0))
fmt.Printf("C multiply result: %f\n", product) // Output: C multiply result: 6.280000
}字符串是 Go 与 C 交互中最常见的类型之一，cgo 提供了专门的函数进行转换。
示例：字符串转换
package main
/*
#include <stdio.h>
#include <stdlib.h> // For malloc/free
// C function that returns a dynamically allocated string
char* create_c_string() {
char* s = (char*)malloc(sizeof(char) * 15);
sprintf(s, "Dynamic C Str");
return s;
}
// C function that takes a string and returns a modified one
char* modify_c_string(char* input) {
char* output = (char*)malloc(sizeof(char) * (strlen(input) + 10));
sprintf(output, "Modified: %s", input);
return output;
}
*/
import "C"
import (
"fmt"
"unsafe"
)
func main() {
// C 函数返回动态分配的 char*
cDynamicStr := C.create_c_string()
goDynamicStr := C.GoString(cDynamicStr)
fmt.Printf("Dynamic C string: %s\n", goDynamicStr)
C.free(unsafe.Pointer(cDynamicStr)) // 释放 C 分配的内存
// Go string 转换为 C char*，传递给 C 函数，再转换回来
goInput := "Hello Go"
cInput := C.CString(goInput) // Go 分配并需要释放的 C 字符串
cOutput := C.modify_c_string(cInput)
goOutput := C.GoString(cOutput)
fmt.Printf("Modified string: %s\n", goOutput)
C.free(unsafe.Pointer(cInput)) // 释放 C.CString 分配的内存
C.free(unsafe.Pointer(cOutput)) // 释放 C modify_c_string 分配的内存
}Go 的切片（slice）和 C 的数组（或指针）在概念上相似，但在内存管理和结构上有所不同。直接转换需要更谨慎的操作，通常涉及 unsafe.Pointer 和 reflect 包。
C 数组/指针到 Go 切片： 这需要知道 C 数组的起始地址和长度。Go 的切片由三部分组成：指向底层数组的指针、长度和容量。我们可以通过 unsafe.Pointer 将 C 数组的地址转换为 Go 指针，然后结合 reflect.SliceHeader 来构造 Go 切片。
package main
/*
#include <stdlib.h> // For malloc
int* create_int_array(int size) {
int* arr = (int*)malloc(sizeof(int) * size);
for (int i = 0; i < size; i++) {
arr[i] = i * 10;
}
return arr;
}
*/
import "C"
import (
"fmt"
"reflect"
"unsafe"
)
func main() {
arraySize := 5
// C 函数返回一个 C int 数组的指针
cArray := C.create_int_array(C.int(arraySize))
// 将 C int 数组转换为 Go []int 切片
// 注意：这里只是创建了一个 Go 切片头，底层数据仍然是 C 分配的
// 必须确保在 Go 切片不再使用后，C 内存被释放
var goSlice []int
sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&goSlice))
sliceHeader.Cap = arraySize
sliceHeader.Len = arraySize
sliceHeader.Data = uintptr(unsafe.Pointer(cArray))
fmt.Println("Go slice from C array:", goSlice) // Output: Go slice from C array: [0 10 20 30 40]
// 释放 C 数组内存
C.free(unsafe.Pointer(cArray))
}Go 切片到 C 数组/指针： 可以通过 &slice[0] 获取 Go 切片底层数组的第一个元素的地址，并将其转换为 unsafe.Pointer 传递给 C。注意： Go 垃圾回收器可能会移动 Go 内存，因此在 C 代码中使用 Go 指针时要非常小心，通常只适用于短期的、同步的 C 函数调用。更安全的方法是在 C 侧分配内存，然后将 Go 切片数据复制过去。
package main
/*
#include <stdio.h>
#include <stdlib.h> // For malloc/free
void print_c_array(int* arr, int size) {
printf("C array: [");
for (int i = 0; i < size; i++) {
printf("%d", arr[i]);
if (i < size - 1) {
printf(", ");
}
}
printf("]\n");
}
// C function that takes a C array and modifies it
void modify_c_array(int* arr, int size) {
for (int i = 0; i < size; i++) {
arr[i] *= 2;
}
}
*/
import "C"
import (
"fmt"
"unsafe"
)
func main() {
goSlice := []int{1, 2, 3, 4, 5}
sliceLen := len(goSlice)
// 方案一：直接传递 Go 切片底层指针 (短时、同步调用)
// 这种方法风险较高，因为 Go GC 可能会移动内存
// 仅适用于 C 函数立即使用指针且不存储的情况
C.print_c_array((*C.int)(unsafe.Pointer(&goSlice[0])), C.int(sliceLen))
// 方案二：在 C 侧分配内存并复制数据 (更安全)
cArray := C.malloc(C.size_t(sliceLen) * C.sizeof_int)
// 将 Go 切片数据复制到 C 内存
for i, v := range goSlice {
*(*C.int)(unsafe.Pointer(uintptr(cArray) + uintptr(i)*C.sizeof_int)) = C.int(v)
}
C.print_c_array((*C.int)(cArray), C.int(sliceLen))
C.modify_c_array((*C.int)(cArray), C.int(sliceLen))
C.print_c_array((*C.int)(cArray), C.int(sliceLen))
// 如果需要将修改后的 C 数组内容读回 Go 切片
for i := 0; i < sliceLen; i++ {
goSlice[i] = int(*(*C.int)(unsafe.Pointer(uintptr(cArray) + uintptr(i)*C.sizeof_int)))
}
fmt.Println("Go slice after C modification:", goSlice) // Output: Go slice after C modification: [2 4 6 8 10]
C.free(cArray) // 释放 C 分配的内存
}Go 结构体和 C 结构体可以通过字段名称和类型进行映射。cgo 会尝试自动匹配，但需要注意字段的对齐方式。通常，Go 结构体字段的顺序应与 C 结构体保持一致。当 Go 结构体包含指针字段时，情况会变得复杂，因为 Go 垃圾回收器无法追踪 C 分配的内存。
cgo 为 Go 语言提供了强大的能力，使其能够与 C 语言世界无缝连接。理解并掌握 Go 与 C 之间的数据类型转换机制，特别是字符串和数组/切片的处理，是有效利用 cgo 的关键。同时，严格遵守内存管理规则，谨慎使用 unsafe 包，并充分考虑性能和并发影响，将有助于构建健壮、高效的 Go-C 混合应用。
以上就是掌握 Go 与 C 互操作：数据类型转换详解的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
630
收藏
