个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
30
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章Go与C语言的互操作实现由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
Go有强烈的C背景，除了语法具有继承性外，其设计者以及其设计目标都与C语言有着千丝万缕的联系。在Go与C语言互操作(Interoperability)方面，Go更是提供了强大的支持。尤其是在Go中使用C，你甚至可以直接在Go源文件中编写C代码，这是其他语言所无法望其项背的.
在如下一些场景中，可能会涉及到Go与C的互操作:
1、提升局部代码性能时，用C替换一些Go代码。C之于Go，好比汇编之于C。 2、嫌Go内存GC性能不足，自己手动管理应用内存。 3、实现一些库的Go Wrapper。比如Oracle提供的C版本OCI，但Oracle并未提供Go版本的以及连接DB的协议细节，因此只能通过包装C OCI版本的方式以提供Go开发者使用。 4、Go导出函数供C开发者使用(目前这种需求应该很少见)。 5、Maybe more… 。
下面是一个短小的例子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package main
// #include <stdio.h>
// #include <stdlib.h>
/*
void print(char *str) {
printf("%s\n", str);
}
*/
import "C"
import "unsafe"
func main() {
s := "Hello Cgo"
cs := C.CString(s)
C.print(cs)
C.free(unsafe.Pointer(cs))
}
|
与"正常"Go代码相比，上述代码有几处"特殊"的地方： 1) 在开头的注释中出现了C头文件的include字样 2) 在注释中定义了C函数print 3) import的一个名为C的"包" 4) 在main函数中居然调用了上述的那个C函数-print 。
没错，这就是在Go源码中调用C代码的步骤，可以看出我们可直接在Go源码文件中编写C代码.
首先，Go源码文件中的C代码是需要用注释包裹的，就像上面的include 头文件以及print函数定义； 其次，import "C"这个语句是必须的，而且其与上面的C代码之间不能用空行分隔，必须紧密相连。这里的"C"不是包名，而是一种类似名字空间的概念，或可以理解为伪包，C语言所有语法元素均在该伪包下面； 最后，访问C语法元素时都要在其前面加上伪包前缀，比如C.uint和上面代码中的C.print、C.free等.
我们如何来编译这个go源文件呢？其实与"正常"Go源文件没啥区别，依旧可以直接通过go build或go run来编译和执行。但实际编译过程中，go调用了名为cgo的工具，cgo会识别和读取Go源文件中的C元素，并将其提取后交给C编译器编译，最后与Go源码编译后的目标文件链接成一个可执行程序。这样我们就不难理解为何Go源文件中的C代码要用注释包裹了，这些特殊的语法都是可以被Cgo识别并使用的.
在Go中可以用如下方式访问C原生的数值类型:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
C.
char
,
C.schar (
signed
char
),
C.uchar (unsigned
char
),
C.
short
,
C.ushort (unsigned
short
),
C.
int
, C.uint (unsigned
int
),
C.
long
,
C.ulong (unsigned
long
),
C.longlong (
long
long
),
C.ulonglong (unsigned
long
long
),
C.
float
,
C.
double
|
Go的数值类型与C中的数值类型不是一一对应的。因此在使用对方类型变量时少不了显式转型操作，如Go doc中的这个例子:
|
1
2
3
4
5
6
7
|
func Random() int {
return int(C.random())//C.long -> Go的int
}
func Seed(i int) {
C.srandom(C.uint(i))//Go的uint -> C的uint
}
|
原生数值类型的指针类型可按Go语法在类型前面加上*，比如var p *C.int。而void*比较特殊，用Go中的unsafe.Pointer表示。任何类型的指针值都可以转换为unsafe.Pointer类型，而unsafe.Pointer类型值也可以转换为任意类型的指针值。unsafe.Pointer还可以与uintptr这个类型做相互转换。由于unsafe.Pointer的指针类型无法做算术操作，转换为uintptr后可进行算术操作.
C语言中并不存在正规的字符串类型，在C中用带结尾'\0'的字符数组来表示字符串；而在Go中，string类型是原生类型，因此在两种语言互操作是势必要做字符串类型的转换.
通过C.CString函数，我们可以将Go的string类型转换为C的"字符串"类型，再传给C函数使用。就如我们在本文开篇例子中使用的那样:
|
1
2
3
|
s :=
"Hello Cgo\n"
cs := C.CString(s)
C.print(cs)
|
不过这样转型后所得到的C字符串cs并不能由Go的gc所管理，我们必须手动释放cs所占用的内存，这就是为何例子中最后调用C.free释放掉cs的原因。在C内部分配的内存，Go中的GC是无法感知到的，因此要记着释放.
通过C.GoString可将C的字符串(*C.char)转换为Go的string类型，例如:
|
1
2
3
4
5
6
7
8
9
10
11
|
// #include <stdio.h>
// #include <stdlib.h>
// char *foo = "hellofoo";
import
"C"
import
"fmt"
func main() {
… …
fmt.Printf(
"%s\n"
, C.GoString(C.foo))
}
|
C语言中的数组与Go语言中的数组差异较大，后者是值类型，而前者与C中的指针大部分场合都可以随意转换。目前似乎无法直接显式的在两者之间进行转型，官方文档也没有说明。但我们可以通过编写转换函数，将C的数组转换为Go的Slice(由于Go中数组是值类型，其大小是静态的，转换为Slice更为通用一些)，下面是一个整型数组转换的例子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
// int cArray[] = {1, 2, 3, 4, 5, 6, 7};
func CArrayToGoArray(cArray unsafe.Pointer, size
int
) (goArray []
int
) {
p := uintptr(cArray)
for
i :=0; i < size; i++ {
j := *(*
int
)(unsafe.Pointer(p))
goArray = append(goArray, j)
p += unsafe.Sizeof(j)
}
return
}
func main() {
… …
goArray := CArrayToGoArray(unsafe.Pointer(&C.cArray[0]), 7)
fmt.Println(goArray)
}
|
执行结果输出：[1 2 3 4 5 6 7] 。
这里要注意的是：Go编译器并不能将C的cArray自动转换为数组的地址，所以不能像在C中使用数组那样将数组变量直接传递给函数，而是将数组第一个元素的地址传递给函数.
除了原生类型外，我们还可以访问C中的自定义类型.
|
1
2
3
4
5
6
7
8
|
// enum color {
// RED,
// BLUE,
// YELLOW
// };
var e, f, g C.enum_color = C.RED, C.BLUE, C.YELLOW
fmt.Println(e, f, g)
|
输出：0 1 2 。
对于具名的C枚举类型，我们可以通过C.enum_xx来访问该类型。如果是匿名枚举，则似乎只能访问其字段了.
|
1
2
3
4
5
6
7
8
9
10
|
// struct employee {
// char *id;
// int age;
// };
id := C.CString("1247")
var employee C.struct_employee = C.struct_employee{id, 21}
fmt.Println(C.GoString(employee.id))
fmt.Println(employee.age)
C.free(unsafe.Pointer(id))
|
输出： 1247 21 。
和enum类似，我们可以通过C.struct_xx来访问C中定义的结构体类型.
这里我试图用与访问struct相同的方法来访问一个C的union:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
// #include <stdio.h>
// union bar {
// char c;
// int i;
// double d;
// };
import
"C"
func main() {
var b *C.union_bar =
new
(C.union_bar)
b.c = 4
fmt.Println(b)
}
|
不过编译时，go却报错：b.c undefined (type *[8]byte has no field or method c)。从报错的信息来看，Go对待union与其他类型不同，似乎将union当成[N]byte来对待，其中N为union中最大字段的size(圆整后的)，因此我们可以按如下方式处理C.union_bar:
|
1
2
3
4
5
6
|
func main() {
var b *C.union_bar = new(C.union_bar)
b[0] = 13
b[1] = 17
fmt.Println(b)
}
|
输出：&[13 17 0 0 0 0 0 0] 。
在Go中访问使用用typedef定义的别名类型时，其访问方式与原实际类型访问方式相同。如:
|
1
2
3
4
5
6
7
8
|
// typedef int myint;
var a C.myint = 5
fmt.Println(a)
// typedef struct employee myemployee;
var m C.struct_myemployee
|
从例子中可以看出，对原生类型的别名，直接访问这个新类型名即可。而对于复合类型的别名，需要根据原复合类型的访问方式对新别名进行访问，比如myemployee实际类型为struct，那么使用myemployee时也要加上struct_前缀.
实际上上面的例子中我们已经演示了在Go中是如何访问C的变量和函数的，一般方法就是加上C前缀即可，对于C标准库中的函数尤其是这样。不过虽然我们可以在Go源码文件中直接定义C变量和C函数，但从代码结构上来讲，大量的在Go源码中编写C代码似乎不是那么“专业”。那如何将C函数和变量定义从Go源码中分离出去单独定义呢？我们很容易想到将C的代码以共享库的形式提供给Go源码.
Cgo提供了#cgo指示符可以指定Go源码在编译后与哪些共享库进行链接。我们来看一下例子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package main
// #cgo LDFLAGS: -L ./ -lfoo
// #include <stdio.h>
// #include <stdlib.h>
// #include "foo.h"
import "C"
import "fmt“
func main() {
fmt.Println(C.count)
C.foo()
}
|
我们看到上面例子中通过#cgo指示符告诉go编译器链接当前目录下的libfoo共享库。C.count变量和C.foo函数的定义都在libfoo共享库中。我们来创建这个共享库:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
// foo.h
int count;
void foo();
//foo.c
#include "foo.h"
int count = 6;
void foo() {
printf("I am foo!\n");
}
$> gcc -c foo.c
$> ar rv libfoo.a foo.o
|
我们首先创建一个静态共享库libfoo.a，不过在编译Go源文件时我们遇到了问题:
|
1
2
3
4
|
$> go build foo.go
# command-line-arguments
/tmp/go-build565913544/command-line-arguments.a(foo.cgo2.)(.text): foo: not defined
foo(0): not defined
|
提示foo函数未定义。通过-x选项打印出具体的编译细节，也未找出问题所在。不过在Go的问题列表中我发现了一个issue(http://code.google.com/p/go/issues/detail?id=3755)，上面提到了目前Go的版本不支持链接静态共享库.
那我们来创建一个动态共享库试试:
|
1
2
|
$> gcc -c foo.c
$> gcc -shared -Wl,-soname,libfoo.so -o libfoo.so foo.o
|
再编译foo.go，的确能够成功。执行foo.
|
1
2
3
|
$> go build foo.go && go
6
I am foo!
|
还有一点值得注意，那就是Go支持多返回值，而C中并没不支持。因此当将C函数用在多返回值的调用中时，C的errno将作为err返回值返回，下面是个例子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
package main
// #include <stdlib.h>
// #include <stdio.h>
// #include <errno.h>
// int foo(int i) {
// errno = 0;
// if (i > 5) {
// errno = 8;
// return i – 5;
// } else {
// return i;
// }
//}
import "C"
import "fmt"
func main() {
i, err := C.foo(C.int(8))
if err != nil {
fmt.Println(err)
} else {
fmt.Println(i)
}
}
$> go run foo.go
exec format error
|
errno为8，其含义在errno.h中可以找到:
|
1
|
#define ENOEXEC 8 /* Exec format error */
|
的确是“exec format error”.
与在Go中使用C源码相比，在C中使用Go函数的场合较少。在Go中，可以使用"export + 函数名"来导出Go函数为C所使用，看一个简单例子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package main
/*
#include <stdio.h>
extern void GoExportedFunc();
void bar() {
printf("I am bar!\n");
GoExportedFunc();
}
*/
import "C"
import "fmt"
//export GoExportedFunc
func GoExportedFunc() {
fmt.Println("I am a GoExportedFunc!")
}
func main() {
C.bar()
}
|
不过当我们编译该Go文件时，我们得到了如下错误信息:
# command-line-arguments /tmp/go-build163255970/command-line-arguments/_obj/bar.cgo2.o: In function `bar': ./bar.go:7: multiple definition of `bar' /tmp/go-build163255970/command-line-arguments/_obj/_cgo_export.o:/home/tonybai/test/go/bar.go:7: first defined here collect2: ld returned 1 exit status 。
代码似乎没有任何问题，但就是无法通过编译，总是提示“多重定义”。翻看Cgo的文档，找到了些端倪。原来 。
There is a limitation: if your program uses any //export directives, then the C code in the comment may only include declarations (extern int f();), not definitions (int f() { return 1; }). 。
似乎是// extern int f()与//export f不能放在一个Go源文件中。我们把bar.go拆分成bar1.go和bar2.go两个文件:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
// bar1.go
package main
/*
#include <stdio.h>
extern void GoExportedFunc();
void bar() {
printf("I am bar!\n");
GoExportedFunc();
}
*/
import "C"
func main() {
C.bar()
}
|
|
1
2
3
4
5
6
7
8
9
10
11
|
// bar2.go
package main
import "C"
import "fmt"
//export GoExportedFunc
func GoExportedFunc() {
fmt.Println("I am a GoExportedFunc!")
}
|
编译执行:
|
1
2
3
4
|
$> go build -o bar bar1.go bar2.go
$> bar
I am bar!
I am a GoExportedFunc!
|
个人觉得目前Go对于导出函数供C使用的功能还十分有限，两种语言的调用约定不同，类型无法一一对应以及Go中类似Gc这样的高级功能让导出Go函数这一功能难于完美实现，导出的函数依旧无法完全脱离Go的环境，因此实用性似乎有折扣.
虽然Go提供了强大的与C互操作的功能，但目前依旧不完善，比如不支持在Go中直接调用可变个数参数的函数(issue975)，如printf(因此，文档中多用fputs).
这里的建议是：尽量缩小Go与C间互操作范围.
什么意思呢？如果你在Go中使用C代码时，那么尽量在C代码中调用C函数。Go只使用你封装好的一个C函数最好。不要像下面代码这样:
|
1
2
3
|
C.
fputs
(…)
C.
atoi
(..)
C.
malloc
(..)
|
而是将这些C函数调用封装到一个C函数中，Go只知道这个C函数即可.
|
1
|
C.foo(..)
|
相反，在C中使用Go导出的函数也是一样.
到此这篇关于Go与C语言的互操作实现的文章就介绍到这了,更多相关Go与C语言互操作内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。
原文链接：https://tonybai.com/2012/09/26/interoperability-between-go-and-c/ 。
最后此篇关于Go与C语言的互操作实现的文章就讲到这里了,如果你想了解更多关于Go与C语言的互操作实现的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
30
4
0
我正在使用 go 图表库 https://github.com/wcharczuk/go-chart制作条形图。我面临的问题是标签值很长，我想将文本旋转 45 度以显示完整文本 我喜欢显示的日期格式是
我在构建一个非常简单的通过 cgo 调用 c 代码的 go 程序时遇到了问题。我的设置: $: echo $GOPATH /go $: pwd /go/src/main $: ls ctest.c
没有 C 的背景，只有 Go 的“初学者”经验，我正在尝试弄清楚 main.go 是实际需要的还是只是一个约定。 我想创建一个简单的网络 API，但有人可以为我澄清一下吗？ 最佳答案 main.go
我read从 Go 1.4 开始，Go 运行时是用 Go 本身编写的(而不是用 C)。 这怎么可能？如果 Go 程序在运行时之上运行，并且运行时是 Go 程序，那么运行时是否在自身之上运行？ 最佳答案
这是“Go 之旅”中的代码示例 Range and Close : package main import ( "fmt" ) func fibonacci(n int, c chan int
给定以下 go.mod 文件: module foo go 1.12 require ( github.com/bar/baz v1.0.0 github.com/rat/cat v1
我有一个 CI/CD 管道，它需要跨平台并与几个不同的管理程序一起工作。为了不必更改 Windows 和 Linux 的构建任务，我认为 Go 将是编写一次代码并在任何地方运行的好方法。然而，考虑到
我有一个 Dockerfile，用于使用 go build 编译 Go 应用程序。我进行了研究，确实建议将 go build 用于生产。 但是我找不到正确的答案来解释为什么。 我了解 go run 创
我尝试在命令提示符#Go lang 中运行该程序-但是当我键入运行“go run hello.go”命令时，我开始了 CreateFile hello.go:The system cannot fin
我正在使用“Go 编程语言”一书学习 Go。第一章介绍os.Open用于读取文件的模块。我尝试打开如下所示的 go 文件。 f, err = os.Open("helloworld.go") 我收
关闭。这个问题需要details or clarity .它目前不接受答案。 想改进这个问题？通过 editing this post 添加详细信息并澄清问题. 2年前关闭。 Improve this
为了解决我对 goroutine 的一些误解，我去了 Go 操场跑了 this code : package main import ( "fmt" ) func other(done cha
这个问题在这里已经有了答案: Evaluate/Execute Golang code/expressions like js' eval() (5 个回答) 1年前关闭。 对于任何 go 程序，我想
这是我基本上试图从路径打印基准的代码。 这意味着，如果用户输入“/some/random/path.java”，则输出将为“path”。同样，如果用户arg为“/another/myapp.c”，则输
$ go version 1.13.3 我的文件夹结构如下: GOPATH +---src +--- my-api-server +--- my-auth-server
这个问题在这里已经有了答案: How to embed file for later parsing execution use (4 个答案) What's the best way to bun
我觉得这有点奇怪，为什么这段代码不起作用？ package main import "fmt" func main() { var i, j int = 1, 2 k
go编译器执行完如下命令后的可执行文件存放在哪里？ $> go run file.go 最佳答案 在 /tmp 文件夹中，如果您使用的是 unix 机器。 如果您使用的是 Windows，则在 \Us
我目前正在开始使用 Go，并且已经深入研究了有关包命名和工作区文件夹结构的注意事项。 不过，我不太确定如何根据 Go 范式正确组织我的代码。 这是我当前的结构示例，它位于 $GOPATH/src 中:
假设我有一个接受用户输入的 Lua 程序，而该输入恰好是有效的 Lua 源代码。这是在程序仍在运行时进行清理、编译和执行的。 Go 是否(或将)实现这样的事情？ 最佳答案 我认为以下两个项目之间有足够
我是一名优秀的程序员,十分优秀！