在GO中调用C源代码#基础篇1

开坑说明

最近在编写客户端程序或与其他部门做功能集成时多次碰到了跨语言的sdk集成，虽说方案很多诸如rpc啊，管道啊，文件io啊，unix socket啊之类的不要太多，顺便研究了下在go调用标准c接口的种种方法与坑，内容不少，有空便慢慢更新了。

内嵌形式

先让我们来看一个最简单的cgo实例

package main

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

func main() {
        C.puts(C.CString("Hello World"))
}

输出

Hello World

通过"C包"调用了c中常见的puts函数同时传入通过C.Cstring把go 中string转化为的c string(相当于char *)。其实“C”这个并不是一个包，而是通过import "C"语句启用了go编译器cgo相关的功能让gcc也参与到了编译中。这种方式通过紧贴在import "C"语句上面的注释中编写c代码并在后续代码中使用C对象调用。当然也可以通过这种方式调用自定义的c函数。

package main
import "C"

/*#include <stdio.h>

void say_hello_with_name(char * name){
        printf("hello %s\n", name);
}
 */
import "C"

func main() {
        C.say_hello_with_name(C.CString("oscar"))
}

输出

hello oscar

外置的C代码

内置的C代码固然很方便，但用到cgo大多数的使用场景是我有一个需要复用的c代码库，像是c++的stl库亦或者是linux c中的什么已经封装好的第三方依赖。这些时候便需要外置一些c的文件.h .c .cpp之类与.go文件混编。先看一个最简单的例子（调用linux的系统账户认证）。

// auth.h
int auth(char *user, char *passwd);

// auth.c
#include <shadow.h>
#include <stdio.h>
#include <unistd.h>

int auth(char *user, char *passwd){
    char *obtpwd;
    struct spwd *spasswd;

    spasswd = getspnam(user);
    obtpwd = crypt(passwd, spasswd->sp_pwdp);
    if(strcmp(spasswd->sp_pwdp, obtpwd) == 0)
    return 0;
    else return 1;
}

// main.go
package main

/*
#cgo LDFLAGS: -lcrypt

#include "auth.h"
*/
import "C"
import "fmt"

func main() {
        var username, password string

        fmt.Println("Please enter your username and password: ")
    _, _ = fmt.Scanln(&username, &password)

        rst := C.auth(C.CString(username), C.CString(password))
        fmt.Println(rst)
}

保证上述三个文件在同一个go工程目录下运行 go build -o main 构建工程。#cgo LDFLAGS: -lcrypt 这个一行是cgo给gcc的编译参数，相关的编译参数与连接参数有空了在后面的文章里说明，-lcrypt 表示编译时需要去连接libcrypt这个库。

调用C的静态库

注意，这种c go 混编的方式个人是不建议的，cgo对外置c代码片构建支持非常差，我无法在cgo中通过编译参数指定c代码片的搜索路径（头文件倒是没啥问题），这也就意味着当项目被调用的c代码片都得在项目根目录下，这可太糟糕了。个人觉得如果有大量的外部依赖c语言的库请分开编译，c库使用gcc编译成静态或动态库在让go在编译时连接为好，写个makefile分开分步编译也不是什么麻烦事，还是上面的例子，让我们把编译的过程稍加修改。

1. 构建libauth.a静态库

gcc -c -o auth.o -lcrypt auth.c
ar rcs libauth.a auth.o

得到libauth.a

2. 对main.go稍加修改

package main

/*
#cgo CFLAGS: -I./
#cgo LDFLAGS: -L. -lauth -lcrypt

#include "auth.h"
*/
import "C"
import "fmt"

func main() {
        var username, password string

        fmt.Println("Please enter your username and password: ")
    _, _ = fmt.Scanln(&username, &password)

        rst := C.auth(C.CString(username), C.CString(password))
        fmt.Println(rst)
}

此处修改主要是新增了libauth.a静态库的链接参数

3. 编译

go build -o main main.go

可以把上述的步骤整下写个简单的makefile

.PHONY : all

all: main

libauth.a: auth.c
        gcc -c -o auth.o -lcrypt auth.c
        ar rcs libauth.a auth.o

main: main.go libauth.a
        go build -o main main.go

clean:
        rm -f auth.o libauth.a main

这样也让我们得出产物的过程变得相对简单快捷

调用C的动态库

比起静态库动态库更加的灵活，它不会在编译阶段和主程序直接打包在一起而类似一个外置函数库而且对外仅对接口负责，这使得程序的某些功能升级或是插件集成变得方便（仅修改动态库即可）。

动态库的调用和静态库类似，此处我做如何动态加载相关的说明（因为你动态加载了其实和cgo没啥大的关系，有关系也不是你处理的，而是动态加载包处理的），仅说明如何在编译阶段链接动态库。

还是上面的那个例子，构建动态库。

package main

/*
#cgo CFLAGS: -I.
#cgo LDFLAGS: -L. -lauth

#include "auth.h"
*/
import "C"
import "fmt"

func main() {
        var username, password string

        fmt.Println("Please enter your username and password: ")
    _, _ = fmt.Scanln(&username, &password)

        rst := C.auth(C.CString(username), C.CString(password))
        fmt.Println(rst)
}

gcc -shared -lcrypt -fPIC -o libauth.so auth.c
go build -o main main.go # go编译器会根据编译参数自动去找libauth.so这个库

编译完成后为动态库创建软连接让系统可以找到它

ln -s /home/tmp/test2/libauth.so /lib64/libauth.so

之后便可正常运行

编译和链接参数

1. 编译参数: CFLAGS/CPPFLAGS/CXXFLAGS

这仨只要记住CFLAGS是纯C风格的编译参数，CPPFLAGS是C/C++的编译参数，CXXFLAGS是纯C++使用的编译参数。为什么会有这三个区别呢，很好理解c++是c的超集（差不多可以这么说），但c和c++的编译参数还是有很大的区别的，此处便做以不同的编译参数区分。此处列举部分CFLAGS参数

-c              用于把源码文件编译成 .o 对象文件,不进行链接过程
-o              用于连接生成可执行文件，在其后可以指定输出文件的名称
-g              用于在生成的目标可执行文件中，添加调试信息，可以使用GDB进行调试
-Idir           用于把新目录添加到include路径上，可以使用相对和绝对路径，“-I.”、“-I./include”、“-I/opt/include”
-Wall           生成常见的所有告警信息，且停止编译，具体是哪些告警信息，请参见GCC手册，一般用这个足矣！
-w              关闭所有告警信息
-O              表示编译优化选项，其后可跟优化等级0\1\2\3，默认是0，不优化
-fPIC           用于生成位置无关的代码
-v              (在标准错误)显示执行编译阶段的命令，同时显示编译器驱动程序,预处理器,编译器的版本号

最常见的参数使用便是指定头文件的搜索路径，像是这样

#cgo CFLAGS: : -I./include

2. 链接参数: LDFLAGS

主要是用于指定在编译阶段连接库的搜索路径和链接库名称。这个就比较简单-L后面跟搜索路径，-l后面跟要链接的库名称。举个栗子。我要连接一个在/home/self_lib/下名字叫做libsuperme.so的库，那么我就可以这么写

#cgo LDFLAGS: -L/home/self_lib/ -lsuperme

指的一提的是-L后面跟的路径不能为相对路径，但你如果写了./这样的相对路径，cgo编译器还是会给你转成绝对路径的，如果连接库在当前的源码目录（编译阶段）也可以利用{SRCDIR}这个宏，可以这样写

#cgo LDFLAGS: -L{SRCDIR} -lsuperme

pkg-config

为不同 c/c++库编写编译和链接参数是非常繁琐的，因此cgo提供了pkg-config 工具支持，此工具可以通过pkg-config xxx -cflags命令生成参数。此功能本人未使用到待后续有空了试试，在大量使用第三方c/c++库时应该可以节约大量的时间成本。