锐客网

  1. 首页 > 生活百科 > it技术 > >

go语言调用自己的函数包 go语言调用so或者dll文件

函数IT技术

go语言如何调用c函数直接嵌入c源代码到go代码里面
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");
}
需要注意go语言调用自己的函数包的是C代码必须放在注释里面
import "C"语句和前面go语言调用自己的函数包的C代码之间不能有空行
运行结果
$ go build main.go./main
Hello C: 12
Hello Go
分开c代码到单独文件
嵌在一起代码结构不是很好看 ， 很多人包括我，还是喜欢把两个分开，放在不同的文件里面，显得干净，go源文件里面是go的源代码，c源文件里面是c的源代码 。
$ ls
hello.chello.hmain.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，所以只能编译成动态链接 。
Go语言中怎么通过一个字符串调用对应名称的函数按值传递函数参数go语言调用自己的函数包，是拷贝参数的实际值到函数的形式参数的方法调用 。在这种情况下go语言调用自己的函数包，参数在函数内变化对参数不会有影响 。
默认情况下，Go编程语言使用调用通过值的方法来传递参数 。在一般情况下 ， 这意味着，在函数内码不能改变用来调用所述函数的参数 。考虑函数swap()的定义如下 。
代码如下:
/* function definition to swap the values */
func swap(int x, int y) int {
var temp int
temp = x /* save the value of x */
x = y/* put y into x */
y = temp /* put temp into y */
return temp;
}
现在，让我们通过使实际值作为在以下示例调用函数swap()：
代码如下:
package main
import "fmt"
func main() {
/* local variable definition */
var a int = 100
var b int = 200
fmt.Printf("Before swap, value of a : %d\n", a )
fmt.Printf("Before swap, value of b : %d\n", b )
/* calling a function to swap the values */
swap(a, b)
fmt.Printf("After swap, value of a : %d\n", a )
fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x, y int) int {
var temp int
temp = x /* save the value of x */
x = y/* put y into x */
y = temp /* put temp into y */
return temp;
}
让我们把上面的代码放在一个C文件，编译并执行它，它会产生以下结果：
Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :100
After swap, value of b :200
这表明，参数值没有被改变，虽然它们已经在函数内部改变 。
通过传递函数参数，即是拷贝参数的地址到形式参数的参考方法调用 。在函数内部，地址是访问调用中使用的实际参数 。这意味着，对参数的更改会影响传递的参数 。
要通过引用传递的值，参数的指针被传递给函数就像任何其他的值 。所以，相应的 ， 需要声明函数的参数为指针类型如下面的函数swap()，它的交换两个整型变量的值指向它的参数 。
代码如下:
/* function definition to swap the values */
func swap(x *int, y *int) {
var temp int
temp = *x/* save the value at address x */
*x = *y/* put y into x */
*y = temp/* put temp into y */
}
现在，让我们调用函数swap()通过引用作为在下面的示例中传递数值：
代码如下:
package main
import "fmt"
func main() {
/* local variable definition */
var a int = 100
var b int= 200
fmt.Printf("Before swap, value of a : %d\n", a )
fmt.Printf("Before swap, value of b : %d\n", b )
/* calling a function to swap the values.
* a indicates pointer to a ie. address of variable a and
* b indicates pointer to b ie. address of variable b.
*/
swap(a, b)
fmt.Printf("After swap, value of a : %d\n", a )
fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x *int, y *int) {
var temp int
temp = *x/* save the value at address x */
*x = *y/* put y into x */
*y = temp/* put temp into y */
}
让我们把上面的代码放在一个C文件，编译并执行它 ， 它会产生以下结果：
Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :200
After swap, value of b :100
这表明变化的功能以及不同于通过值调用的外部体现的改变不能反映函数之外 。
go怎么调用自己用c/c写的so中的方法直接调用so的函数cgo应该绕不开吧 ， 我写过一个银行的应用程序调用其特色业务接口，因为接口只支持c和java，我就封装了一个c的so ， 然后用cgo调用后写了一个RPC供远程的go语言调用，因为RPC只负责信息交互不负责业务逻辑，所以写了不到百行，以后基本不用再改 。记住虽然go语言自带gc，但cgo还是要手工释放内存哦 。
【go语言调用自己的函数包 go语言调用so或者dll文件】go语言调用自己的函数包的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于go语言调用so或者dll文件、go语言调用自己的函数包的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：路由器如何访问 路由器怎么访问服务器共享

    下一篇：程序员如何应对服务器失效的情况？ 程序员服务器失效了吗怎么办