关于go:CGO-初步认知和基本数据类型转换

CGO 是什么？

CGO 是 GO 语言外面的一个个性，CGO 属于 GOLANG 的高级用法，次要是通过应用 GOLANG 调用 CLANG 实现的程序库

应用

咱们能够应用

import "C" 来应用 CGO 这个个性

一个最简略的 CGO 应用

package main//#include <stdio.h>import "C"func main(){    C.puts(C.CString("Hello, Cgo\n"))}

import "C" 的上方能够写须要导入的库 C 库，须要正文起来，CGO 会将此处的正文内容当做 C 的代码，被称为序言（preamble）

上述代码的性能解释

应用 CGO 包的 C.CString 函数将 Go 语言字符串转为 C 语言字符串

最初调用 CGO 包的 C.puts 函数向规范输入窗口打印转换后的 C 字符串

应用 go build -x main.go 编译一下

加上 -x 能够打印出编译过程中执行的指令

# go build -x main.goWORK=/tmp/go-build594331603mkdir -p $WORK/b001/cat >$WORK/b001/importcfg.link << 'EOF' # internalpackagefile command-line-arguments=/root/.cache/go-build/fb/fbb37eeb6735cb453f6d92e2e3f46f14d9dceb5baa1cdd10aae11d1d47d60e55-dpackagefile runtime/cgo=/usr/local/go/pkg/linux_amd64/runtime/cgo.apackagefile syscall=/usr/local/go/pkg/linux_amd64/syscall.apackagefile runtime=/usr/local/go/pkg/linux_amd64/runtime.apackagefile errors=/usr/local/go/pkg/linux_amd64/errors.apackagefile internal/bytealg=/usr/local/go/pkg/linux_amd64/internal/bytealg.apackagefile internal/oserror=/usr/local/go/pkg/linux_amd64/internal/oserror.apackagefile internal/race=/usr/local/go/pkg/linux_amd64/internal/race.apackagefile internal/unsafeheader=/usr/local/go/pkg/linux_amd64/internal/unsafeheader.apackagefile sync=/usr/local/go/pkg/linux_amd64/sync.apackagefile internal/cpu=/usr/local/go/pkg/linux_amd64/internal/cpu.apackagefile runtime/internal/atomic=/usr/local/go/pkg/linux_amd64/runtime/internal/atomic.apackagefile runtime/internal/math=/usr/local/go/pkg/linux_amd64/runtime/internal/math.apackagefile runtime/internal/sys=/usr/local/go/pkg/linux_amd64/runtime/internal/sys.apackagefile internal/reflectlite=/usr/local/go/pkg/linux_amd64/internal/reflectlite.apackagefile sync/atomic=/usr/local/go/pkg/linux_amd64/sync/atomic.aEOFmkdir -p $WORK/b001/exe/cd ./usr/local/go/pkg/tool/linux_amd64/link -o $WORK/b001/exe/a.out -importcfg $WORK/b001/importcfg.link -buildmode=exe -buildid=Vv0to6CWqbWf5_KTN66F/K36AEO-x4qJ_LJbz5wgG/HVbBbLSaW0sTSwlN8TzN/Vv0to6CWqbWf5_KTN66F -extld=gcc /root/.cache/go-build/fb/fbb37eeb6735cb453f6d92e2e3f46f14d9dceb5baa1cdd10aae11d1d47d60e55-d/usr/local/go/pkg/tool/linux_amd64/buildid -w $WORK/b001/exe/a.out # internalmv $WORK/b001/exe/a.out mainrm -r $WORK/b001/

尝试本人写一个 C 函数，让 GO 来调用他

Go语言环境中调用这个 SayHello 函数

package main/*#include <stdio.h>static void SayHello(const char* s) {    puts(s);}*/import "C"func main(){    C.SayHello(C.CString("hello xiaomotong study cgo\n"))}

尝试本人写一个 C 文件，而后 GO 中进行导入和调用

xmtC.h

void SayHi(const char * str);

xmtC.c

(必须是同级目录下的 .c 文件，cgo 应用 go build 编译的时候，会默认在同级目录下找 .c 文件进行编译，如果咱们是须要将 C 文件做成动态库 或者 动静库的形式，那么就不要将 C 的源码文件放到同级目录下了，防止重名)

#include <stdio.h>#include "xmtC.h"void SayHi(const char * str){    puts(str);}

main.go

package main//void SayHi(const char * str);import "C"func main(){    C.SayHi(C.CString("hello xiaomotong study cgo\n"))}

间接运行 go build 进行编译，运行可执行程序即可

# go build# lscgo  main.go  xmtC.c# ./cgohello xiaomotong study cgo

通过面向C语言接口的编程技术，咱们不仅仅解放了函数的实现者，同时也简化的函数的使用者。当初咱们能够将 SayHi 当作一个规范库的函数应用（和puts函数的应用形式相似）

咱们也能够在 go 文件中写成这个样子

package main//#include <xmtC.h>import "C"func main(){    C.SayHi(C.CString("hello xiaomotong study cgo\n"))}

合并 C 和 GO 的代码

在Go1.10中CGO新减少了一个_GoString_预约义的C语言类型，用来示意Go语言字符串

// +build go1.10package main//void SayHi(_GoString_ s);import "C"import (    "fmt")func main() {    C.SayHi("hello xiaomotong study cgo\n")}//export SayHifunc SayHi(s string) {    fmt.Print(s)}

上述代码的具体执行逻辑程序是这样的：

CGO 环境

应用 CGO 须要肯定的环境环境反对

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

上述的例子中，咱们有几个须要留神的点：

• import "C" 语句不能和其余的 import 语句放在一起，须要独自一行搁置
• 上述咱们在GO外面传递的值，例如 C.CString("hello xiaomotong study cgo\n") 是调用了 C 的虚构包，将字符串转换成 C 的字符串传入进去

• Go是强类型语言

  所以 cgo 中传递的参数类型必须与申明的类型完全一致，而且传递前必须用 ”C” 中的转化函数转换成对应的C类型，不能间接传入Go中类型的变量

  通过虚构的 C 包导入的C语言符号并不须要是大写字母结尾，它们不受Go语言的导出规则束缚

cgo 用法

咱们能够应用 #cgo 语句设置编译阶段和链接阶段的相干参数

• 编译阶段的参数

次要用于定义相干宏和指定头文件检索门路

• 链接阶段的参数

次要是指定库文件检索门路和要链接的库文件

例如咱们能够这样

// #cgo CFLAGS: -DPNG_DEBUG=1 -I./include// #cgo LDFLAGS: -L/usr/local/lib -lpng// #include <png.h>import "C"

CFLAGS

• -DPNG_DEBUG

定义宏 PNG_DEBUG ，设置为 1

• -I

定义头文件的检索目录是 ./include

LDFLAGS

• -L

指定链接时库文件检索目录 ，能够通过写 ${SRCDIR}来示意以后包的绝对路径

• -l

指定链接时须要的库，此处是 png 库

条件编译 build tag

就是在咱们 go build 的时候，增加一些条件参数，当然这个条件参数在对应的文件中是须要有的，

例如上述咱们应用 Go1.10 的时候，就在文件中增加了 // +build go1.10

咱们能够这样用：

go build -tags="debug"go build -tags="debug test"go build -tags="linux,386"

go build 的时候加上 -tags 参数，若有多个咱们能够一起写，用空格距离，示意 或，用逗号距离示意与

GO 和 C 数据类型互相转换

cgo 官网提供了如下的数据类型转换：

须要留神 3 个点：

• CGO 中，C 语言的int和long类型都是对应4个字节的内存大小，size_t 类型能够当作Go语言 uint 无符号整数类型看待
• CGO 中，C 语言的int固定为4字节的大小 ， GO 语言的 int 和 uint 却在32位和64位零碎下别离对应 4 个字节和 8 个字节大小
• 例如数据类型两头有空格，unsigned int 不能间接通过 C.unsigned int 拜访，能够应用typedef关键字提供一个规定的类型命名，这样更利于在CGO中拜访

字符串和切片类型

CGO生成的 _cgo_export.h 头文件中有 GO 外面字符串，切片，通道，字典，接口等数据类型对应的示意形式，然而咱们个别应用有价值的就是字符串和切片了

因为 CGO 没有提供其余数据类型的辅助函数

typedef struct { const char *p; GoInt n; } GoString;

咱们导出函数的时候能够这样写：

应用 _GoString_预约义类型，这样写能够升高在 cgo 代码中可能对 _cgo_export.h 头文件产生的循环依赖的危险

_GoString_ 是 Go1.10 针对 Go 专门加的字符

extern void helloString(_GoString_ p0);

咱们能够应用官网提供的函数计算字符串的长度 和 获取字符串的地址：

size_t _GoStringLen(_GoString_ s);const char *_GoStringPtr(_GoString_ s);

struct ，union，enum

GO 语言中拜访 C 语言的 struct ，union，enum，能够查看下表的对应关系

对于构造体 struct

构造体的内存布局依照 C 语言的通用对齐规定

在32位Go语言环境 C 语言构造体也依照32位对齐规定，在64位Go语言环境依照64位的对齐规定

对于指定了非凡对齐规定的构造体，无奈在 CGO 中拜访

GO 中能够这样拜访 C 的构造体

package main/*struct struct_TEST {    int i;    float f;};*/import "C"import "fmt"func main() {    var a C.struct_TEST    a.i = 1    a.f = 2    fmt.Println(a.i)    fmt.Println(a.f)}

须要留神如下 2 个大点：

• 构造体成员的名字和 GO 中关键字的名字一样咋解决

例如上述构造体成员名字是这样的

struct struct_TEST {    int type;    float f;};

那么咱们拜访 type 的时候，能够这样拜访a._type 即可

若构造体是这样的呢？

struct struct_TEST {    int type;    float _type;};

咱们拜访的时候依然是这样拜访， a._type ，不过理论拜访到的是 float _type; ，通过 GO 就没有方法拜访到 int type;

GO 中也无法访问 C 中的 零长数组 和 位字段，例如

struct struct_TEST {    int   size: 10; // 位字段无法访问    float arr[];    // 零长的数组无法访问};

• 在 C 语言中，无奈间接拜访 Go 语言定义的构造体类型

对于枚举 enum

枚举类型底层对应int类型，反对正数类型的值 ， 咱们能够间接应用 C.xx 来进行拜访

例如枚举类型为：

enum TEST {    ONE,    TWO,};

应用这个类型咱们能够用 c C.enum_TEST

给这个变量复制的时候，咱们能够这样做：c = C.ONE

对于联合体 union

Go 语言中并不反对 C 语言联结类型，它们会被转为对应大小的字节数组

例如

union B1 {    int i;    float f;};

union B1 会被转换成为 4 个字节大小的 字节数组 [4]uint8

GO 中操作联合体变量有 3 种形式：

• 在C语言中定义辅助函数
• Go语言的 encoding/binary 手工解码成员(须要留神大端小端问题)
• 应用unsafe包强制转型为对应类型

举个例子

package main/*#include <stdint.h>union TEST {    int i;    float f;};*/import "C"import (    "fmt"    "unsafe")func main() {    var b C.union_TEST    *(*C.int)(unsafe.Pointer(&b)) = 1    fmt.Println("b.i:", *(*C.int)(unsafe.Pointer(&b)))    fmt.Println("b.f:", *(*C.float)(unsafe.Pointer(&b)))}

咱们读取和写入联合体变量的时候，应用 unsafe 包性能是最好的，通过unsafe 获取指针，而后转成对应的数据类型的指针即可

参考资料：

GO 高级编程

欢送点赞，关注，珍藏

敌人们，你的反对和激励，是我保持分享，提高质量的能源

好了，本次就到这里

技术是凋谢的，咱们的心态，更应是凋谢的。拥抱变动，背阴而生，致力向前行。

我是小魔童哪吒，欢送点赞关注珍藏，下次见~