Go与C & CGo编程

本文档详细介绍CGo编程技术，包括Go调用C代码、C调用Go代码、内存管理和性能优化等核心内容。

📋 目录

• CGo概述
• 基础语法
• 数据类型转换
• 内存管理
• 高级特性
• 性能优化
• 最佳实践

CGo概述

CGo是Go语言提供的强大功能，允许Go程序与C语言代码无缝交互，实现性能优化和库复用。

核心功能

功能	描述	应用场景
Go调用C	在Go中直接调用C函数	性能优化、系统API调用
C调用Go	导出Go函数供C使用	回调函数、插件系统
库集成	使用现有C/C++库	OpenSSL、SQLite、FFmpeg
底层操作	直接操作内存和硬件	驱动开发、嵌入式编程

使用场景

// 典型的CGo使用场景
/*
1. 性能关键代码：数学计算、图像处理
2. 系统调用：操作系统API、硬件接口
3. 第三方库：现有的C/C++库集成
4. 遗留代码：将现有C代码迁移到Go项目
*/

基础语法

Go调用C代码

1. 内联C代码

package main

/*
#include <stdio.h>
#include <stdlib.h>

// C函数定义
void hello_from_c() {
    printf("Hello from C!\n");
}

int add_numbers(int a, int b) {
    return a + b;
}

char* get_message() {
    return "Message from C";
}
*/
import "C"
import (
    "fmt"
    "unsafe"
)

func main() {
    // 调用C函数
    C.hello_from_c()
    
    // 调用带参数的C函数
    result := C.add_numbers(10, 20)
    fmt.Printf("10 + 20 = %d\n", result)
    
    // 处理C字符串
    cstr := C.get_message()
    gostr := C.GoString(cstr)
    fmt.Printf("Message: %s\n", gostr)
}

2. 外部C文件

math_ops.h:

#ifndef MATH_OPS_H
#define MATH_OPS_H

// 函数声明
double calculate_pi(int iterations);
int factorial(int n);
void sort_array(int* arr, int size);

#endif

math_ops.c:

#include "math_ops.h"
#include <stdlib.h>

double calculate_pi(int iterations) {
    double pi = 0.0;
    for (int i = 0; i < iterations; i++) {
        pi += (i % 2 == 0 ? 1.0 : -1.0) / (2 * i + 1);
    }
    return pi * 4;
}

int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

void sort_array(int* arr, int size) {
    // 简单的冒泡排序
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

main.go:

package main

/*
#include "math_ops.h"
*/
import "C"
import (
    "fmt"
    "unsafe"
)

func main() {
    // 计算π值
    pi := C.calculate_pi(1000000)
    fmt.Printf("π ≈ %.10f\n", float64(pi))
    
    // 计算阶乘
    fact := C.factorial(10)
    fmt.Printf("10! = %d\n", int(fact))
    
    // 排序数组
    arr := []int{64, 34, 25, 12, 22, 11, 90}
    fmt.Printf("Original: %v\n", arr)
    
    // 转换为C数组
    cArr := (*C.int)(C.malloc(C.size_t(len(arr)) * C.size_t(unsafe.Sizeof(C.int(0)))))
    defer C.free(unsafe.Pointer(cArr))
    
    // 复制数据到C数组
    slice := (*[1000]C.int)(unsafe.Pointer(cArr))[:len(arr):len(arr)]
    for i, v := range arr {
        slice[i] = C.int(v)
    }
    
    // 调用C排序函数
    C.sort_array(cArr, C.int(len(arr)))
    
    // 复制结果回Go
    for i := range arr {
        arr[i] = int(slice[i])
    }
    fmt.Printf("Sorted:   %v\n", arr)
}

C调用Go代码

导出Go函数

package main

/*
#include <stdio.h>

// 声明Go函数（由Go导出）
extern int go_add(int a, int b);
extern void go_callback(int value);

// C函数调用Go函数
void call_go_functions() {
    printf("Calling Go functions from C:\n");
    
    int result = go_add(15, 25);
    printf("go_add(15, 25) = %d\n", result);
    
    go_callback(42);
}
*/
import "C"
import "fmt"

//export go_add
func go_add(a, b C.int) C.int {
    return a + b
}

//export go_callback
func go_callback(value C.int) {
    fmt.Printf("Go callback received: %d\n", int(value))
}

func main() {
    fmt.Println("Demonstrating C calling Go functions:")
    C.call_go_functions()
}

import "C" // 必须单独一行，且紧跟在 C 代码注释后

func main() { C.helloFromC() // 调用 C 函数 }

**运行结果：**

Hello from C!

### **(2) 调用外部 C 库（如 math.h）**

package main

/* #include <math.h> */ import "C" import "fmt"

func main() { x := C.sqrt(25.0) // 调用 C 的 sqrt 函数 fmt.Println(x) // 输出: 5 }

**编译方式：**

go run main.go

------

## **3. CGO 的典型应用场景**

| 场景              | 说明                                                 |
| ----------------- | ---------------------------------------------------- |
| **系统编程**      | 调用 Linux/Windows 系统 API（如 `ioctl`, `syscall`） |
| **高性能计算**    | 使用 C 优化算法（如矩阵运算、图像处理）              |
| **复用现有 C 库** | 集成 SQLite、OpenCV、TensorFlow C API 等             |
| **硬件交互**      | 直接操作硬件寄存器或驱动                             |
| **与 C++ 交互**   | 通过 C 包装器调用 C++ 代码                           |

------

## **4. CGO 的工作原理**

1. **编译过程**： Go 编译器 (`go build`) 会识别 `import "C"`，并调用 **C 编译器（如 gcc/clang）** 编译嵌入的 C 代码。 生成的目标文件（`.o`）和 Go 代码一起链接成最终的可执行文件。 
2. **数据类型转换**： Go 的 `int` 和 C 的 `int` 不同，需使用 `C.int` 等类型显式转换。 字符串需通过 `C.CString()` 和 `C.GoString()` 转换（注意内存管理）。 

------

## **5. 进阶用法**

### **(1) 调用外部 C 文件**

**目录结构：**

. ├── main.go └── mylib.c

**mylib.c：**

#include <stdio.h>

void customPrint(const char* msg) { printf("C says: %s\n", msg); }

**main.go：**

package main

/* #include "mylib.c" */ import "C"

func main() { msg := C.CString("Hello from Go!") C.customPrint(msg) defer C.free(unsafe.Pointer(msg)) // 释放 C 分配的内存 }

**编译运行：**

go run main.go

**输出：**

C says: Hello from Go!

### **(2) 使用现有的 C 动态库（.so/.dll）**

package main

/* #cgo LDFLAGS: -L. -lmylib #include "mylib.h" */ import "C"

func main() { C.libFunction() // 调用动态库中的函数 }

**编译方式：**

go build -o app

------

## **6. CGO 的注意事项**

| 问题             | 解决方案                                                     |
| ---------------- | ------------------------------------------------------------ |
| **内存管理**     | C 分配的堆内存需手动释放（`C.free`），Go 的 GC 不管理 C 内存 |
| **类型差异**     | Go 的 `string` 和 C 的 `char*` 需转换（`C.CString`/`C.GoString`） |
| **跨平台兼容性** | 需处理不同系统的 C 头文件和库路径（`#cgo` 指令）             |
| **性能开销**     | CGO 调用比纯 Go 调用慢（约 10-100ns 额外开销）               |
| **编译依赖**     | 需安装 C 编译器（如 `gcc`）                                  |

------

## **7. 替代方案**

如果 CGO 的复杂性或性能开销成为问题，可以考虑：

1. **纯 Go 实现**（如用 `syscall` 替代部分 C 调用）。
2. **使用 Rust + FFI**（通过 `cgo` 调用 Rust 编译的 C ABI 库）。
3. **WebAssembly**（将 C 代码编译为 WASM，由 Go 调用）。

------

## **总结**

- **CGO 是 Go 调用 C 的官方桥梁**，适合需要复用 C 代码或访问底层硬件的场景。
- **核心语法**：`import "C"` + `/* C 代码 */`。
- **典型用途**：调用系统 API、优化性能、集成 C 库。
- **注意事项**：内存管理、类型转换、跨平台支持。

**示例项目参考**：[Go 官方 CGO 文档](https://golang.org/cmd/cgo/)