cgo 机制

Go语言是通过自带的CGO工具来支持C语言函数调用,同时可用Go语言导出C动态库接口给其它语言使用。

查看是否开启:

window:

go env |findstr "CGO"

linux:

go env |grep "CGO"

CGO 环境

使用 CGO 需要一定的环境环境支持,Cgo依赖Gcc工作

linux 下 需要有 gcc/g++ 的编译环境
windows 下需要有 MinGW 工具
需要把 GO 的环境变量 CGO_ENABLED 置为 1

基于 C 标准库实现最简单的 CGO 程序

复制代码
// hello.go
package main

//#include <stdio.h>
import "C"

func main() {
    C.puts(C.CString("Hello, this is a CGO demo.\n"))
}
复制代码

注意:

1)导入 C 代码前的注解用//或者/* */,注解内容可以包含任何 C 代码,例如:函数、变量的声明定义、库引用等。(该注解要紧挨导入语句)

2)import "C" 语句不能和其他的 import 语句放在一起,需要单独一行放置,在C代码和import”C”之间不能有空行【表示启用CGO】

3)上述在GO里面传递的值,例如 C.CString("hello xiaomotong study cgo\n") 是调用了 C 的虚拟包,将字符串转换成 C 的字符串传入进去

4)Go是强类型语言,所以 cgo 中传递的参数类型必须与声明的类型完全一致,而且传递前必须用 ”C” 中的转化函数转换成对应的C类型,不能直接传入Go中类型的变量。通过虚拟的 C 包导入的C语言符号并不需要是大写字母开头,它们不受Go语言的导出规则约束

5)使用C.CString函数转换GoString为CString时,要手动释放该字符串

6)需要特别留意,交叉编译时会默认关闭 CGO

 

基于自己写的 C 函数构建 CGO 程序

下面再来看个例子。先自定义一个叫 SayHello 的 C 函数来实现打印,然后从 Go 语言环境中调用这个 SayHello 函数:

复制代码
// hello.go
package main

/*
#include <stdio.h>
static void SayHello(const char* s) {
    puts(s);
}
*/
import "C"

func main() {
    C.SayHello(C.CString("Hello, World\n"))
}
复制代码

除了 SayHello 函数是我们自己实现的之外,其它的部分和前面的例子基本相似。

我们也可以将 SayHello 函数放到当前目录下的一个 C 语言源文件中(后缀名必须是.c)。因为是编写在独立的 C 文件中,为了允许外部引用,所以需要去掉函数的 static 修饰符。

复制代码
// hello.c

#include <stdio.h>

void SayHello(const char* s) {
    puts(s);
}
复制代码

然后在 CGO 部分先声明 SayHello 函数,其它部分不变:

复制代码
// hello.go
package main

//void SayHello(const char* s);
import "C"

func main() {
    C.SayHello(C.CString("Hello, World\n"))
}
复制代码

其实 CGO 不仅仅用于 Go 语言中调用 C 语言函数,还可以用于导出 Go 语言函数给 C 语言函数调用。

用 C 接口的方式实现 Go 编程

复制代码
// main.go
package main

//void SayHello(char* s);
import "C"

import (
    "fmt"
)

func main() {
    C.SayHello(C.CString("Hello, World\n"))
}

//export SayHello
func SayHello(s *C.char) {
    fmt.Print(C.GoString(s))
}
复制代码

虽然看起来全部是 Go 语言代码,但是执行的时候是先从 Go 语言的 main 函数,到 CGO 自动生成的 C 语言版本 SayHello 桥接函数,最后又回到了 Go 语言环境的 SayHello 函数。这个代码包含了 CGO 编程的精华。

CGO 的主要基础参数

import "C" 语句说明
如果在 Go 代码中出现了 import "C" 语句则表示使用了 CGO 特性,紧跟在这行语句前面的注释是一种特殊语法,里面包含的是正常的 C 语言代码。当确保 CGO 启用的情况下,还可以在当前目录中包含 C/C++对应的源文件。比如上面的例子。

#cgo 语句说明

在 import "C" 语句前的注释中可以通过 #cgo 语句设置编译阶段和链接阶段的相关参数。编译阶段的参数主要用于定义相关宏和指定头文件检索路径。链接阶段的参数主要是指定库文件检索路径和要链接的库文件。

在 import "C" 语句前的注释中可以通过 #cgo 语句设置编译阶段和链接阶段的相关参数。编译阶段的参数主要用于定义相关宏和指定头文件检索路径。链接阶段的参数主要是指定库文件检索路径和要链接的库文件。

为什么要引入 CGO

突破 Go 创建切片的内存限制

由于 Go 语言实现的限制,无法在 Go 语言中创建大于 2GB 内存的切片(可参考 makeslice 实现源码)。不过借助 cgo 技术,可以在 C 语言环境创建大于 2GB 的内存,然后转为 Go 语言的切片使用:

复制代码
package main

/*
#include <stdlib.h>

void* makeslice(size_t memsize) {
    return malloc(memsize);
}
*/
import "C"
import "unsafe"

func makeByteSlize(n int) []byte {
    p := C.makeslice(C.size_t(n))
    return ((*[1 << 31]byte)(p))[0:n:n]
}

func freeByteSlice(p []byte) {
    C.free(unsafe.Pointer(&p[0]))
}

func main() {
    s := makeByteSlize(1<<32+1)
    s[len(s)-1] = 255
    print(s[len(s)-1])
    freeByteSlice(s)
}
复制代码

例子中我们通过 makeByteSlize 来创建大于 4G 内存大小的切片,从而绕过了 Go 语言实现的限制。而 freeByteSlice 辅助函数则用于释放从 C 语言函数创建的切片。

因为 C 语言内存空间是稳定的,基于 C 语言内存构造的切片也是稳定的,不会因为 Go 语言栈的变化而被移动。

方便在 Go 语言中接入使用 C/C++的软件资源

CGO 提供了 golang 和 C 语言相互调用的机制。而在某些第三方库可能只有 C/C++ 的实现,也没有必要用纯 golang 重新实现,因为可能工作量比较大,比较耗时,这时候 CGO 就派上用场了。

被调用的 C 代码可以直接以源代码形式提供或者打包静态库或动态库在编译时链接。

这里推荐使用静态库的方式,这样方便代码隔离,也符合 Go 的哲学。

CGO 带来的问题

1)构建时间变长

当在 Go 包中导入 "C" 时,go build 需要做更多的工作来构建代码。

需要调用 cgo 工具来生成 C 到 Go 和 Go 到 C 的相关代码。
系统中的 C 编译器会为软件包中的每个 C 文件进行调用处理。
各个编译单元被合并到一个 .o 文件中。
生成的 .o 文件会通过系统的链接器,对其引用的共享对象进行修正。

2)构建变得复杂

在引入了 cgo 之后,你需要设置所有的环境变量,跟踪可能安装在奇怪地方的共享对象和头文件等。

另外需要注意,Go 支持许多的平台,而 cgo 并不是。需要安装 C 编译器,而不仅仅是 Go 编译器。而且可能还需要安装你的项目所依赖的 C 语言库,这也是需要技术成本的。

3)Go 和 C 内存模型不同【内存泄露】

内存管理变得复杂,C 没有垃圾回收,需要手动管理内存,而 go 有gc机制,两者的内存管理机制不同,可能会带来内存泄漏。
CGO 是 Go 语言和 C 语言的桥梁,它使二者在二进制接口层面实现了互通,但是我们要注意因两种语言的内存模型的差异而可能引起的问题。
如果在 CGO 处理的跨语言函数调用时涉及到了指针的传递,则可能会出现 Go 语言和 C 语言共享某一段内存的场景。
C 语言的内存在分配之后就是稳定的,但是 Go 语言因为函数栈的动态伸缩可能导致栈中内存地址的移动(这是 Go 和 C 内存模型的最大差异)。如果 C 语言持有的是移动之前的 Go 指针,那么以旧指针访问 Go 对象时会导致程序崩溃。

例如使用了 cStr := C.CString("hello world !"),最后记得调用C.free(unsafe.Pointer(cStr))释放当前变量申请的内存空间。

使用 C 静态库实现

CGO 在使用 C/C++资源的时候一般有三种形式:

直接使用源码;
链接静态库;
链接动态库。

直接使用源码就是在 import "C" 之前的注释部分包含 C 代码,或者在当前包中包含 C/C++源文件。

链接静态库和动态库的方式比较类似,都是通过在 LDFLAGS 选项指定要链接的库方式链接。这里主要关注在 CGO 中如何使用静态库的问题。

总结

CGO其实是 C 语言和 Go 语言混合编程的技术,因此要想熟练地使用 CGO 是非常有必要要了解这两门语言的。

任何技术和语言都有它自身的优点和不足,Go 语言不是银弹,它无法解决全部问题。而通过 CGO 可以做到以下几点:

通过 CGO 可接入 C/C++的世纪软件遗产
通过 CGO 可以用 Go 给其它系统写 C 接口的共享库
通过 CGO 技术也可以让 Go 语言编写的代码可以很好地融入现有的软件生态

而现在的软件确实大多数是建立在 C/C++语言之上的。因此 CGO 可以说是一个统筹兼备的技术,是 Go 的一个重量级的技术,也是值得任何一个 Go 语言开发人员学习的。

posted @   李若盛开  阅读(198)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 【.NET】调用本地 Deepseek 模型
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
点击右上角即可分享
微信分享提示