go语言如何调用c函数

直接嵌入c源代码到go代码里面

创新互联网站建设公司，提供成都网站设计、网站建设、外贸网站建设，网页设计，建网站，PHP网站建设等专业做网站服务;可快速的进行网站开发网页制作和功能扩展；专业做搜索引擎喜爱的网站，是专业的做网站团队，希望更多企业前来合作!

package main

/*

#include stdio.h

void myhello(int i) {

printf("Hello C: %d\n", i);

}

*/

import "C"

import "fmt"

func main() {

C.myhello(C.int(12))

fmt.Println("Hello Go");

}

需要注意的是C代码必须放在注释里面

import "C"语句和前面的C代码之间不能有空行

运行结果

$ go build main.go ./main

Hello C: 12

Hello Go

分开c代码到单独文件

嵌在一起代码结构不是很好看，很多人包括我，还是喜欢把两个分开，放在不同的文件里面，显得干净，go源文件里面是go的源代码，c源文件里面是c的源代码。

$ ls

hello.c hello.h main.go

$ cat hello.h

void hello(int);

$ cat hello.c

#include stdio.h

void hello(int i) {

printf("Hello C: %d\n", i);

}

$ cat main.go

package main

// #include "hello.h"

import "C"

import "fmt"

func main() {

C.hello(C.int(12))

fmt.Println("Hello Go");

}

编译运行

$ go build ./main

Hello C: 12

Hello Go

编译成库文件

如果c文件比较多，最好还是能够编译成一个独立的库文件，然后go来调用库。

$ find mylib main

mylib

mylib/hello.h

mylib/hello.c

main

main/main.go

编译库文件

$ cd mylib

# gcc -fPIC -shared -o libhello.so hello.c

编译go程序

$ cd main

$ cat main.go

package main

// #cgo CFLAGS: -I../mylib

// #cgo LDFLAGS: -L../mylib -lhello

// #include "hello.h"

import "C"

import "fmt"

func main() {

C.hello(C.int(12))

fmt.Println("Hello Go");

}

$ go build main.go

运行

$ export LD_LIBRARY_PATH=../mylib

$ ./main

Hello C: 12

Hello Go

在我们的例子中，库文件是编译成动态库的，main程序链接的时候也是采用的动态库

$ ldd main

linux-vdso.so.1 = (0x00007fffc7968000)

libhello.so = ../mylib/libhello.so (0x00007f513684c000)

libpthread.so.0 = /lib64/libpthread.so.0 (0x00007f5136614000)

libc.so.6 = /lib64/libc.so.6 (0x00007f5136253000)

/lib64/ld-linux-x86-64.so.2 (0x000055d819227000)

理论上讲也是可以编译成整个一静态链接的可执行程序，由于我的机器上缺少静态链接的系统库，比如libc.a，所以只能编译成动态链接。

windows 怎么编译 go语言

1、解压压缩包到go工作目录，如解压到E:\opensource\go\go，解压后的目录结构如下：

E:\opensource\go\go

├─api

├─bin

│ ├─go.exe

│ ├─godoc.exe

│ └─gofmt.exe

├─doc

├─include

├─lib

├─misc

├─pkg

├─src

└─test

2、增加环境变量GOROOT，取值为上面的go工作目录

3、Path环境变量中添加";%GOROOT%\bin"，以便能够直接调用go命令来编译go代码，至此go编译环境就配置好了

注：如果不想手动设置系统环境变量，也可下载go启动环境批处理附件，

修改goenv.bat文件中的GOROOT值为上面的go工作目录后直接双击该bat文件，go编译环境变量即设置完成。

4、测试go编译环境，启动一个cmd窗口，直接输入go，看到下面的提示就是搭建成功了

E:\opensource\go\gogo

Go is a tool for managing Go source code.

Usage:

go command [arguments]

The commands are:

build compile packages and dependencies

clean remove object files

doc run godoc on package sources

env print Go environment information

fix run go tool fix on packages

fmt run gofmt on package sources

get download and install packages and dependencies

install compile and install packages and dependencies

list list packages

run compile and run Go program

test test packages

tool run specified go tool

version print Go version

vet run go tool vet on packages

Use "go help [command]" for more information about a command.

Additional help topics:

gopath GOPATH environment variable

packages description of package lists

remote remote import path syntax

testflag description of testing flags

testfunc description of testing functions

Use "go help [topic]" for more information about that topic.

5、编译helloworld测试程序，go语言包中test目录带有helloworld.go测试程序，源码见"附一 helloworld.go"，

直接调用"go build helloworld.go"就生成了"helloworld.exe"可执行程序，运行一下这个程序看到了我们期望的hello,wolrd。

E:\opensource\go\go\testgo build helloworld.go

E:\opensource\go\go\testhelloworld.exe

hello, world

E:\opensource\go\go\test

附一 helloworld.go

// cmpout

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Test that we can do page 1 of the C book.

package main

func main() {

print("hello, world\n")

}

如何在golang 中调用c的静态库或者动态库

Cgo 使得Go程序能够调用C代码. cgo读入一个用特别的格式写的Go语言源文件, 输出Go和C程序, 使得C程序能打包到Go语言的程序包中.

举例说明一下. 下面是一个Go语言包, 包含了两个函数 -- Random 和 Seed -- 是C语言库中random和srandom函数的马甲.

package rand

/*

#include stdlib.h

*/ import "C" func Random() int { return int(C.random()) } func Seed(i int) { C.srandom(C.uint(i)) }

我们来看一下这里都有什么内容. 开始是一个包的导入语句.

rand包导入了"C"包, 但你会发现在Go的标准库里没有这个包. 那是因为C是一个"伪包", 一个为cgo引入的特殊的包名, 它是C命名空间的一个引用.

rand 包包含4个到C包的引用: 调用 C.random和C.srandom, 类型转换 C.uint(i)还有引用语句.

Random函数调用libc中的random函数, 然后回返结果. 在C中, random返回一个C类型的长整形值, cgo把它轮换为C.long. 这个值必需转换成Go的类型, 才能在Go程序中使用. 使用一个常见的Go类型转换:

func Random() int { return int(C.random()) }

这是一个等价的函数, 使用了一个临时变量来进行类型转换:

func Random() int { var r C.long = C.random() return int(r) }

Seed函数则相反. 它接受一个Go语言的int类型, 转换成C语言的unsigned int类型, 然后传递给C的srandom函数.

func Seed(i int) { C.srandom(C.uint(i)) }

需要注意的是, cgo中的unsigned int类型写为C.uint; cgo的文档中有完整的类型列表.

这个例子中还有一个细节我们没有说到, 那就是导入语句上面的注释.

/*

#include stdlib.h

*/ import "C"

Cgo可以识别这个注释, 并在编译C语言程序的时候将它当作一个头文件来处理. 在这个例子中, 它只是一个include语句, 然而其实它可以是使用有效的C语言代码. 这个注释必需紧靠在import "C"这个语句的上面, 不能有空行, 就像是文档注释一样.

Strings and things

与Go语言不同, C语言中没有显式的字符串类型. 字符串在C语言中是一个以0结尾的字符数组.

Go和C语言中的字符串转换是通过C.CString, C.GoString,和C.GoStringN这些函数进行的. 这些转换将得到字符串类型的一个副本.

下一个例子是实现一个Print函数, 它使用C标准库中的fputs函数把一个字符串写到标准输出上:

package print // #include stdio.h // #include stdlib.h import "C" import "unsafe" func Print(s string) { cs := C.CString(s) C.fputs(cs, (*C.FILE)(C.stdout)) C.free(unsafe.Pointer(cs)) }

在C程序中进行的内存分配是不能被Go语言的内存管理器感知的. 当你使用C.CString创建一个C字符串时(或者其它类型的C语言内存分配), 你必需记得在使用完后用C.free来释放它.

调用C.CString将返回一个指向字符数组开始处的指错, 所以在函数退出前我们把它转换成一个unsafe.Pointer(Go中与C的void 等价的东西), 使用C.free来释放分配的内存. 一个惯用法是在分配内存后紧跟一个defer(特别是当这段代码比较复杂的时候), 这样我们就有了下面这个Print函数:

func Print(s string) { cs := C.CString(s) defer C.free(unsafe.Pointer(cs)) C.fputs(cs, (*C.FILE)(C.stdout)) }

构建 cgo 包

如果你使用goinstall, 构建cgo包就比较容易了, 只要调用像平常一样使用goinstall命令, 它就能自动识别这个特殊的import "C", 然后自动使用cgo来编译这些文件.

如果你想使用Go的Makefiles来构建, 那在CGOFILES变量中列出那些要用cgo处理的文件, 就像GOFILES变量包含一般的Go源文件一样.

rand包的Makefile可以写成下面这样:

include $(GOROOT)/src/Make.inc

TARG=goblog/rand

CGOFILES=\ rand.go\ include $(GOROOT)/src/Make.pkg

然后输入gomake开始构建.

更多 cgo 的资源

cgo的文档中包含了关于C伪包的更多详细的说明, 以及构建过程. Go代码树中的cgo的例子给出了更多更高级的用法.

一个简单而又符合Go惯用法的基于cgo的包是Russ Cox写的gosqlite. 而Go语言的网站上也列出了更多的的cgo包.

最后, 如果你对于cgo的内部是怎么运作这个事情感到好奇的话, 去看看运行时包的cgocall.c文件的注释吧.

如何配置go语言开发环境

1、下载go的zip文件。并且一定要把文件解压到c:\go目录下。

2、配置windows的高级环境变量。包括：GOROOT、GOOS、GOBIN、GOARCH。并且在path变量里面把c:\go\bin加入。以便可以在命令行直接运行go命令。

举例：我的机器：

GOPATH= c:\go;c:\go\src;F:\workspace\goSample01;

GOBIN=c:\go\bin;F:\workspace\goSample01\bin;

其中，c:\go是go的安装路径；

F:\workspace\goSample01是我写的go语言项目的工程目录；

F:\workspace\goSample01\bin是go语言项目的工程目录下的可执行文件路径;

3、在完成环境变量配置后，打开一个命令行窗口，直接输入go，然后回车，看看是否出现go的帮助信息。如果出现，那么go的基本环境就OK了。

注意：这个基本环境不包含开发工具，也不能直接编译带C代码的go程序。

4、

(可选)为了支持Import远程包，最好装个gomingw。下载地址：

/downloads/list。如果下的是压缩包，请把它解压到C盘。例如，C:\gowin-env。里面有个Console.bat是以后使用go

get的环境。举例：有个文件a.go,里面import(

"fmt"

"github.com/astaxie/beedb"

_ "github.com/ziutek/mymysql/godrv"

为了编译该a.go文件，需要启动Console.bat，然后在该命令行窗口，进入c:\go\src目录下，执行go getgithub.com/astaxie/beedb

Go get github.com/ziutek/mymysql/godrv .

Go会自动下载该远程包并编译和安装这些包。

配置goclipse（可选）

（如果不喜欢eclipse开发工具，请跳过这个配置。）

1、下载并安装goclipse插件。Goclipse是go语言for eclipse的插件，下载地址：

2、启动eclipse并创建go项目。然后写个最简单的helloworld.go文件，并运行。代码如下：

packagemainimport"fmt"func main(){ fmt.Printf("hello, world")}

配置gocode（可选）

如果不需要go语法辅助和eclipse里面的（按ALT+/）弹出go语言自动辅助功能，请跳过这个配置。

1、下载gocode的zip文件，解压后放在go的bin目录下。

2、下载并安装Git软件。并且在path里面配置git的执行路径。例如c:\git\bin

3、在命令行执行：go build .\gocode。如果一切正常，那么将会编译生成一个gocode.exe文件在go的bin目录下。如果编译失败，那么就转第4步。

4、如果第3步直接编译gocode源文件成功，那就直接到第5步。否则，就需要通过git下载gocode源文件，然后再编译。在命令行执行：go get -u github.com/nsf/gocode 。就会生成gocode.exe文件。

5、在goclipse插件里面指定gocode的路径。就可以在elcipse里面调用gocode来帮助写编码了。

从开发工具这块看，go语言还不够成熟，开发工具都还不完善，有待改进。

下载go-tour教程源代码（可选）

Google有个在线运行go语言的教程（），很不错。支持在web上直接运行大部分的go程序，想了解这个教程的源代码的朋友可以通过以下方式获取。如果没兴趣，可以跳过这个步骤。

1、下载安装Mercurial软件。

2、在命令行下输入：

hg clone

作为测试用的。如果把http改成https协议，下载就会失败。搞不懂。

编译带调用C代码的go文件（可选）

1、为了在windows下编译带C代码的go程序，你首先需要下载并安装MinGW或者Cygwin。

2、首选安装MinGW。在安装MinGW之后，记得要把MinGW安装目录\bin路径设置在path环境变量里面，以便能在dos窗口下直接调用gcc。

3、下载一个gowin-env。下载地址：gowin-env。下载后解压到某个目录下，例如：C:\gowin-env. 然后，编辑go-env.bat。配置相关的go参数。例如，我的配置是：

set GOARCH=386

set GOOS=windows

set GOROOT=c:\go

set GOBIN=%GOROOT%\bin

set GOPATH=%GOROOT%;F:\workspace\goSample01;

设置好go-env.bat后，就可以点击Console.bat来启动编译和运行窗口。

4、编写一个带C代码的go程序。例如，testc.go

5、编译

例如：

go build -compiler gccgo test_c.go

运行调用C代码的go文件（可选）

1、testc.go.

创建rand目录，然后在rand里面创建testc.go. 代码如下：

package rand

/*

//

#include stdio.h

*/

import "C"

func PrintHello() {

C.puts(C.CString("Hello, world\n"))

}

2、a.go

在rand下创建a.go.代码如下：

package rand

import "fmt"

func SayHello(name string){

fmt.Println(name)

}

3、test_import.go

在rand的上一级创建test_import.go。代码如下：

package main

import "./rand"

func main(){

rand.SayHello("tom")

rand.PrintHello()

}

4、运行test_import.go

go run test_import.go

在测试其它几个C代码的时候，发现windows版本的cgo还有些编译问题，同样的代码转移到苹果的XCODE下就没有问题。后来终于发现原因了，原来有些例子是unix平台下的，而在windows平台下，方法名和参数需要做调整。

例如：下面代码在windows下编译报一堆错误。

package rand

/*

#include stdlib.h

*/

import "C"

func Random() int {

return int(C.random())

}

func Seed(i int) {

C.srandom(C.uint(i))

}

这里需要把return int(C.random()) 修改为“return int(C.rand())”

C.srandom(C.uint(i))修改为“C.srand(C.uint(i))”编译就OK了。

go怎么调用自己用c/c++写的so中的方法

直接调用so的函数cgo应该绕不开吧，我写过一个银行的应用程序调用其特色业务接口，因为接口只支持c和java，我就封装了一个c的so，然后用cgo调用后写了一个RPC供远程的go语言调用，因为RPC只负责信息交互不负责业务逻辑，所以写了不到百行，以后基本不用再改。记住虽然go语言自带gc，但cgo还是要手工释放内存哦。

Go语言的支持平台

LiteIDE是一款专门为Go语言开发的跨平台轻量级集成开发环境（IDE），由QT编写。

LiteIDE主要特点： 支持主流操作系统

Windows

Linux

MacOS X Go编译环境管理和切换

管理和切换多个Go编译环境

支持Go语言交叉编译 与Go标准一致的项目管理方式

基于GOPATH的包浏览器

基于GOPATH的编译系统

基于GOPATH的Api文档检索 Go语言的编辑支持

类浏览器和大纲显示

Gocode(代码自动完成工具)的完美支持

Go语言文档查看和Api快速检索

代码表达式信息显示F1

源代码定义跳转支持F2

Gdb断点和调试支持

gofmt自动格式化支持 其他特征

支持多国语言界面显示

完全插件体系结构

支持编辑器配色方案

基于Kate的语法显示支持

基于全文的单词自动完成

支持键盘快捷键绑定方案

Markdown文档编辑支持

实时预览和同步显示

自定义CSS显示

可导出HTML和PDF文档

批量转换/合并为HTML/PDF文档 Sublime Text 2（以下简称Sublime）+ GoSublime + gocode + MarGo的组合。

其优点有： 自动化提示代码。 保存的时候自动格式化代码，让您编写的代码更加美观，符合Go的标准。 支持项目管理 支持语法高亮 熟悉Java的读者应该对于idea不陌生，idea是通过一个插件来支持go语言的高亮语法，代码提示和重构实现。

新闻标题：go语言调用c库交叉编译,go语言调用c接口
文章位置：http://chengdu.cdxwcx.cn/article/hdided.html