开发前端软件素材源码教程下载网站

全部
网站模板
网页特效
网站源码
素材资源
建站学院
软件工具
mysql mysql 微信 微信 小程序 苹果 dedecms 修真图
当前位置：首页 > 建站学院 > 其他教程 >  Go语言怎么实现CGO编程

Go语言怎么实现CGO编程

其他教程   发布日期：2024年12月02日   浏览次数：108次

本文小编为大家详细介绍“Go语言怎么实现CGO编程”，内容详细，步骤清晰，细节处理妥当，希望这篇“Go语言怎么实现CGO编程”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。

    基于 C 标准库实现最简单的 CGO 程序

    下面是我们构建的最简 CGO 程序：

    1. // hello.go
    2. package main
    3. //#include <stdio.h>
    4. import "C"
    5. func main() {
    6.     C.puts(C.CString("Hello, this is a CGO demo.
    7. "))
    8. }

    基于自己写的 C 函数构建 CGO 程序

    上面就是使用了C标准库中已有的函数来实现的一个简单的 CGO 程序。

    下面我们再来看个例子。先自定义一个叫 SayHello 的 C 函数来实现打印，然后从 Go 语言环境中调用这个 SayHello 函数：

    1. // hello.go
    2. package main
    3. /*
    4. #include &lt;stdio.h&gt;
    5. static void SayHello(const char* s) {
    6.     puts(s);
    7. }
    8. */
    9. import "C"
    10. func main() {
    11.     C.SayHello(C.CString("Hello, World
    12. "))
    13. }

    除了 SayHello 函数是我们自己实现的之外，其它的部分和前面的例子基本相似。

    我们也可以将 SayHello 函数放到当前目录下的一个 C 语言源文件中（后缀名必须是.c）。因为是编写在独立的 C 文件中，为了允许外部引用，所以需要去掉函数的 static 修饰符。

    1. // hello.c
    2. #include <stdio.h>
    3. void SayHello(const char* s) {
    4.     puts(s);
    5. }

    然后在 CGO 部分先声明 SayHello 函数，其它部分不变：

    1. // hello.go
    2. package main
    3. //void SayHello(const char* s);
    4. import "C"
    5. func main() {
    6.     C.SayHello(C.CString("Hello, World
    7. "))
    8. }

    模块化以上例子

    在编程过程中，抽象和模块化是将复杂问题简化的通用手段。当代码语句变多时，我们可以将相似的代码封装到一个个函数中；当程序中的函数变多时，我们将函数拆分到不同的文件或模块中。

    在前面的例子中，我们可以抽象一个名为 hello 的模块，模块的全部接口函数都声明在 hello.h 头文件中：

    1. // hello.h
    2. void SayHello(const char* s);

    下面是 SayHello 函数的 C 语言实现，对应 hello.c 文件：

    1. // hello.c
    2. #include "hello.h"
    3. #include <stdio.h>
    4. void SayHello(const char* s) {
    5.     puts(s);
    6. }

    我们也可以用 C++语言来重新实现这个 C 语言函数：

    1. // hello.cpp
    2. #include <iostream>
    3. extern "C" {
    4.     #include "hello.h"
    5. }
    6. void SayHello(const char* s) {
    7.     std::cout << s;
    8. }

    用 Go 实现 C 函数并导出

    其实 CGO 不仅仅用于 Go 语言中调用 C 语言函数，还可以用于导出 Go 语言函数给 C 语言函数调用。

    在前面的例子中，我们已经抽象一个名为 hello 的模块，模块的全部接口函数都在 hello.h 头文件中定义：

    1. // hello.h
    2. void SayHello(char* s);

    现在我们创建一个 hello.go 文件，用 Go 语言重新实现 C 语言接口的 SayHello 函数:

    1. // hello.go
    2. package main
    3. import "C"
    4. import "fmt"
    5. //export SayHello
    6. func SayHello(s *C.char) {
    7.     fmt.Print(C.GoString(s))
    8. }

    我们通过 CGO 的 

    1. //export SayHello
    指令将 Go 语言实现的函数 
    1. SayHello
    导出为 C 语言函数。为了适配 CGO 导出的 C 语言函数，我们禁止了在函数的声明语句中的 
    1. const
    修饰符。

    通过面向 C 语言接口的编程技术，我们不仅仅解放了函数的实现者，同时也简化的函数的使用者。现在我们可以将 SayHello 当作一个标准库的函数使用，如下:

    1. // main.go
    2. package main
    3. //#include <hello.h>
    4. import "C"
    5. func main() {
    6.     C.SayHello(C.CString("Hello, World
    7. "))
    8. }

    用 C 接口的方式实现 Go 编程

    简单来说就是将上面例子中的几个文件重新合并到一个 Go 文件实现，如下：

    1. // main.go
    2. package main
    3. //void SayHello(char* s);
    4. import "C"
    5. import (
    6.     "fmt"
    7. )
    8. func main() {
    9.     C.SayHello(C.CString("Hello, World
    10. "))
    11. }
    12. //export SayHello
    13. func SayHello(s *C.char) {
    14.     fmt.Print(C.GoString(s))
    15. }

    虽然看起来全部是 Go 语言代码，但是执行的时候是先从 Go 语言的 main 函数，到 CGO 自动生成的 C 语言版本 SayHello 桥接函数，最后又回到了 Go 语言环境的 SayHello 函数。这个代码包含了 CGO 编程的精华。

    CGO 的主要基础参数

    import "C" 语句说明

    如果在 Go 代码中出现了 

    1. import "C"
    语句则表示使用了 CGO 特性，紧跟在这行语句前面的注释是一种特殊语法，里面包含的是正常的 C 语言代码。当确保 CGO 启用的情况下，还可以在当前目录中包含 C/C++对应的源文件。比如上面的例子。

    #cgo 语句说明

    在 

    1. import "C"
    语句前的注释中可以通过 
    1. #cgo
    语句设置编译阶段和链接阶段的相关参数。编译阶段的参数主要用于定义相关宏和指定头文件检索路径。链接阶段的参数主要是指定库文件检索路径和要链接的库文件。

    比如：

    1. // #cgo CFLAGS: -DADDR_DEBUG=1 -I./include
    2. // #cgo LDFLAGS: -L/usr/local/lib -linet_addr
    3. // #include <inet_addr.h>
    4. import "C"

    上面的代码中，

    1. CFLAGS
    部分，
    1. -D
    部分定义了宏 ADDR_DEBUG，值为 1；
    1. -I
    定义了头文件包含的检索目录。
    1. LDFLAGS
    部分，
    1. -L
    指定了链接时库文件检索目录，
    1. -l
    指定了链接时需要链接 
    1. inet_addr
    库。

    因为 C/C++遗留的问题，C 头文件检索目录可以是相对目录，但是库文件检索目录则需要绝对路径。

    为什么要引入 CGO

    突破 Go 创建切片的内存限制

    由于 Go 语言实现的限制，我们无法在 Go 语言中创建大于 2GB 内存的切片（可参考 makeslice 实现源码）。不过借助 cgo 技术，我们可以在 C 语言环境创建大于 2GB 的内存，然后转为 Go 语言的切片使用：

    1. package main
    2. /*
    3. #include <stdlib.h>
    4. void* makeslice(size_t memsize) {
    5.     return malloc(memsize);
    6. }
    7. */
    8. import "C"
    9. import "unsafe"
    10. func makeByteSlize(n int) []byte {
    11.     p := C.makeslice(C.size_t(n))
    12.     return ((*[1 << 31]byte)(p))[0:n:n]
    13. }
    14. func freeByteSlice(p []byte) {
    15.     C.free(unsafe.Pointer(&p[0]))
    16. }
    17. func main() {
    18.     s := makeByteSlize(1<<32+1)
    19.     s[len(s)-1] = 255
    20.     print(s[len(s)-1])
    21.     freeByteSlice(s)
    22. }

    例子中我们通过 makeByteSlize 来创建大于 4G 内存大小的切片，从而绕过了 Go 语言实现的限制。而 freeByteSlice 辅助函数则用于释放从 C 语言函数创建的切片。

    因为 C 语言内存空间是稳定的，基于 C 语言内存构造的切片也是稳定的，不会因为 Go 语言栈的变化而被移动。

    方便在 Go 语言中接入使用 C/C++的软件资源

    CGO 提供了 golang 和 C 语言相互调用的机制。而在某些第三方库可能只有 C/C++ 的实现，也没有必要用纯 golang 重新实现，因为可能工作量比较大，比较耗时，这时候 CGO 就派上用场了。

    被调用的 C 代码可以直接以源代码形式提供或者打包静态库或动态库在编译时链接。

    这里推荐使用静态库的方式，这样方便代码隔离，也符合 Go 的哲学。

    CGO 带来的问题

    构建时间变长

    当你在 Go 包中导入 "C" 时，go build 需要做更多的工作来构建你的代码。

    • 需要调用 cgo 工具来生成 C 到 Go 和 Go 到 C 的相关代码。

    • 系统中的 C 编译器会为软件包中的每个 C 文件进行调用处理。

    • 各个编译单元被合并到一个 .o 文件中。

    • 生成的 .o 文件会通过系统的链接器，对其引用的共享对象进行修正。

    构建变得复杂

    在引入了 cgo 之后，你需要设置所有的环境变量，跟踪可能安装在奇怪地方的共享对象和头文件等。

    另外需要注意，Go 支持许多的平台，而 cgo 并不是。需要安装 C 编译器，而不仅仅是 Go 编译器。而且可能还需要安装你的项目所依赖的 C 语言库，这也是需要技术成本的。

    Go 和 C 内存模型不同

    内存管理变得复杂，C 是没有垃圾收集的，而 go 有，两者的内存管理机制不同，可能会带来内存泄漏。

    CGO 是 Go 语言和 C 语言的桥梁，它使二者在二进制接口层面实现了互通，但是我们要注意因两种语言的内存模型的差异而可能引起的问题。

    如果在 CGO 处理的跨语言函数调用时涉及到了指针的传递，则可能会出现 Go 语言和 C 语言共享某一段内存的场景。

    我们知道 C 语言的内存在分配之后就是稳定的，但是 Go 语言因为函数栈的动态伸缩可能导致栈中内存地址的移动(这是 Go 和 C 内存模型的最大差异)。如果 C 语言持有的是移动之前的 Go 指针，那么以旧指针访问 Go 对象时会导致程序崩溃。

    使用 C 静态库实现

    CGO 在使用 C/C++资源的时候一般有三种形式：

    • 直接使用源码；

    • 链接静态库；

    • 链接动态库。

    直接使用源码就是在 

    1. import "C"
    之前的注释部分包含 C 代码，或者在当前包中包含 C/C++源文件。

    链接静态库和动态库的方式比较类似，都是通过在 

    1. LDFLAGS
    选项指定要链接的库方式链接。这里主要关注在 CGO 中如何使用静态库的问题。

    具体实现

    如果 CGO 中引入的 C/C++资源有代码而且代码规模也比较小，直接使用源码是最理想的方式，但很多时候我们并没有源代码，或者从 C/C++源代码开始构建的过程异常复杂，这种时候使用 C 静态库也是一个不错的选择。

    静态库因为是静态链接，最终的目标程序并不会产生额外的运行时依赖，也不会出现动态库特有的跨运行时资源管理的错误。

    我们先用纯 C 语言构造一个简单的静态库。我们要构造的静态库名叫 sum，库中只有一个 sum_add 函数，用于表示数论中的模加法运算。sum 库的文件都在 sum 目录下。

    sum/sum.h 头文件只有一个纯 C 语言风格的函数声明：

    1. int sum_add(int a, int b);

    sum/sum.c 对应函数的实现：

    1. #include "sum.h"
    2. int sum_add(int a, int b) {
    3.     return a+b;
    4. }

    通过以下命令可以生成一个叫 libsum.a 的静态库：

    1. $ cd ./sum
    2. $ gcc -c -o sum.o sum.c
    3. $ ar rcs libsum.a sum.o

    生成 libsum.a 静态库之后，放到当前的lib目录下，我们就可以在 CGO 中使用该资源了。

    创建 main.go 文件如下：

    1. package main
    2. /*
    3. #cgo CFLAGS: -I./sum
    4. #cgo LDFLAGS: -L./lib -lsum
    5. #include "sum.h"
    6. */
    7. import "C"
    8. import "fmt"
    9. func main() {
    10.     fmt.Println(C.sum_add(10, 5))
    11. }

    其中有两个 

    1. #cgo
    命令，分别是编译和链接参数。

    CFLAGS 通过 

    1. -I./sum
    将 sum 库对应头文件所在的目录加入头文件检索路径。

    LDFLAGS 通过 

    1. -L./lib
    将编译后 sum 静态库所在目录加为链接库检索路径，
    1. -lsum
    表示链接 libsum.a 静态库。

    需要注意的是，在链接部分的检索路径不能使用相对路径（C/C++代码的链接程序所限制）

    实战应用

    这里以一个实际案例(分两块代码)来说明 CGO 如何使用静态库的。案例实现的功能说明：

    • c++ 代码实现初始化配置、解析传入的 mq 消息，并处理具体的逻辑

    • go 代码实现初始化相关配置（mq 等）、监听订单消息等工作

    C++ 代码主要实现

    1. #include <iostream>
    2. extern "C"{
    3.     int init(int logLevel, int disId);
    4.     void RecvAndDealMessage(char* sbuf, int len);
    5. }
    6. // 初始化
    7. int init(int logLevel, int disId)
    8. {
    9.     g_xmfDisId = disId;
    10.      // 服务初始化
    11.     if(CCGI_STUB_CNTL->Initialize() != 0)
    12.     {
    13.         printf("CCGI_STUB_CNTL->Init failed
    14. ");
    15.         return -1;
    16.     }
    17.     CCGI_STUB_CNTL->setTimeout(5);
    18.     // 日志初始化
    19.     std::string strModuleName = "xxxxxx";
    20.     int iRet = MD_LOG->QuickInitForAPP(strModuleName.c_str(), MD_LOG_FILE_PATH, logLevel);
    21.     if (iRet != 0)
    22.     {
    23.         printf("log init failed. module:%s logswitch:%d ret:%d", strModuleName.c_str(), logLevel, iRet);
    24.         return 1;
    25.     }
    26.     else
    27.     {
    28.         printf("Init log Ok
    29. ");
    30.     }
    31.     MD_COMM_LOG_DEBUG("Log Init Finished. level:%d", logLevel);
    32.     return iRet;
    33. }
    34. // 处理消息数据
    35. void RecvAndDealMessage(char* sbuf, int len)
    36. {
    37.     MD_COMM_LOG_DEBUG("Begin receive message...");
    38.     MessageContainer oMsgCon;
    39. 	  char strbuf[1024];
    40. 	  if(len > 1024)
    41. 	  {
    42. 		  MD_COMM_LOG_ERR(MESSAGE_TOO_LONG, "len = %d, message too long.", len);
    43. 		  return ;
    44. 	  }
    45.     snprintf(strbuf, 1024, "%s", sbuf);
    46.     MD_COMM_LOG_DEBUG("recvmessage:[%s] len:[%d]", strbuf, len);
    47.     //解析并处理收到的消息
    48.     DealMsg(strbuf, oMsgCon);
    49. }

    Go 代码主要实现

    main 函数实现：

    1. package main
    2. /*
    3. #cgo LDFLAGS:  -lstdc++
    4. #cgo LDFLAGS: -L../lib  -ldaemon_qiyegou_finacial_deal_listen
    5. #cgo LDFLAGS: -L../lib  -llibrary_util -lcgistub -linet_addr -ljsoncpp
    6. int init(int logLevel, int disId);
    7. void RecvAndDealMessage(char* sbuf, int len);
    8.  */
    9. import "C"
    10. func main()  {
    11.   //解析参数
    12. 		if Init() {
    13. 			defer func() {
    14. 				if err := recover(); err != nil {
    15. 					md_log.Errorf(-100, nil, "panic:%v, stack:%v", err, string(debug.Stack()))
    16. 				}
    17. 			}()
    18. 			for {
    19. 				//业务处理
    20. 				run()
    21. 			}
    22. 		}
    23. }

    init 函数实现：

    1. func Init() bool {
    2. 	iniFile, err := ini.LoadFile(os.Args[1])
    3. 	if err != nil {
    4. 		fmt.Println("load config faild, config:", os.Args[1])
    5. 		return false
    6. 	}
    7. 	logswitch := iniFile.GetInt("biz","logswitch",255)
    8. 	md_log.Init(DAEMON_NAME, iniFile.GetInt("biz","logswitch",255))
    9. 	md_log.Debugf("log init success!")
    10.   // cgo 调用c++初始化函数
    11. 	ret := C.init(C.int(logswitch),C.int(xmf_dis_id))
    12. 	if  ret != 0 {
    13. 		fmt.Printf("init failed ret:%v 
    14. ", ret)
    15. 		return false
    16. 	}
    17. 	fmt.Println("initial success!")
    18. 	return true
    19. }

    run 函数代码：

    1. func run()  {
    2. 	var oConsumer rabbitmq.Consumer
    3. 	oConsumer.Init(Mqdns, MqexchangeName, Mqqueue, Mqroute)
    4. 	msgs, err := oConsumer.StartConsume(Mqqueue,false)
    5. 	if err != nil{
    6. 		fmt.Printf("oConsumer.StartConsume failed:%+v, arg:%+v 
    7. ",err, Mq
    8. 		return
    9. 	}
    10. 	for msg := range msgs{
    11. 		strMsg := string(msg.Body)
    12. 		msg.Ack(true)
    13.     // 调用 C++ 处理消息的函数
    14. 		C.RecvAndDealMessage(C.CString(strMsg), C.int(len(strMsg))) //c++ 处理mq消息
    15. 	}
    16. }

    以上就是Go语言怎么实现CGO编程的详细内容，更多关于Go语言怎么实现CGO编程的资料请关注九品源码其它相关文章！

    相关热词： 语言实现编程
    上一篇：讲一讲如何在一个页面中使用多个百度分享按钮，分享不同的文章
    下一篇：从gitee上下的代码如何用

    文章分类

    IT资讯 CMS教程 服务器 数据库 前端开发 后端开发 工具使用 其他教程

    最后更新

    热门排行

    网站首页 | 关于我们 | 免责声明 | 网站建设 | 在线工具 | 网站地图

    版权声明：本站发布的资源部分自互联网，所有资源版权归原作者所有。如果有侵犯到您的权益，请联系本站删除，谢谢合作！

    Copyright 2018-2025 ©19jp.com All Rights Reserved. 陕ICP备16002142号-1