From e05f794a338a94f34f8b0d1efe3ee4645f3c8968 Mon Sep 17 00:00:00 2001 From: chai2010 Date: Tue, 2 Jan 2018 06:49:21 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=20=E7=AC=AC=E4=BA=8C?= =?UTF-8?q?=E7=AB=A0=20CGO=20=E7=BC=96=E7=A8=8B,=20=E5=8C=85=E5=90=AB=20?= =?UTF-8?q?=E7=AC=AC=E4=B8=80=E5=92=8C=E7=AC=AC=E4=BA=8C=E8=8A=82,=20?= =?UTF-8?q?=E5=90=8E=E7=BB=AD=E9=83=A8=E5=88=86=E5=BE=85=E7=BB=A7=E7=BB=AD?= =?UTF-8?q?=E5=AE=8C=E5=96=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- SUMMARY.md | 10 ++ ch2-cgo/ch2-01-hello-cgo.md | 132 ++++++++++++++ ch2-cgo/ch2-02-cgo-types.md | 347 ++++++++++++++++++++++++++++++++++++ ch2-cgo/ch2-03-basic.md | 3 + ch2-cgo/ch2-04-memory.md | 3 + ch2-cgo/ch2-05-class.md | 3 + ch2-cgo/ch2-06-build.md | 3 + ch2-cgo/ch2-07-dll.md | 4 + ch2-cgo/ch2-08-leveldb.md | 3 + ch2-cgo/ch2-09-faq.md | 3 + ch2-cgo/readme.md | 3 + 11 files changed, 514 insertions(+) create mode 100644 ch2-cgo/ch2-01-hello-cgo.md create mode 100644 ch2-cgo/ch2-02-cgo-types.md create mode 100644 ch2-cgo/ch2-03-basic.md create mode 100644 ch2-cgo/ch2-04-memory.md create mode 100644 ch2-cgo/ch2-05-class.md create mode 100644 ch2-cgo/ch2-06-build.md create mode 100644 ch2-cgo/ch2-07-dll.md create mode 100644 ch2-cgo/ch2-08-leveldb.md create mode 100644 ch2-cgo/ch2-09-faq.md create mode 100644 ch2-cgo/readme.md diff --git a/SUMMARY.md b/SUMMARY.md index d868c29..2023b8d 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -9,6 +9,16 @@ * [1.6. 常见的并发模式](ch1-basic/ch1-06-goroutine.md) * [1.7. 错误和异常](ch1-basic/ch1-07-error-and-panic.md) * [1.8. 配置开发环境](ch1-basic/ch1-08-ide.md) +* [第二章 CGO编程](ch2-cgo/readme.md) + * [2.1. 你好, CGO!](ch2-cgo/ch2-01-hello-cgo.md) + * [2.2. 基础类型转换](ch2-cgo/ch2-02-cgo-types.md) + * [2.3. CGO编程基础](ch2-cgo/ch2-03-basic.md) + * [2.4. CGO内存模型](ch2-cgo/ch2-04-memory.md) + * [2.5. C++类包装](ch2-cgo/ch2-05-class.md) + * [2.6. 命令行工具和构建参数](ch2-cgo/ch2-06-build.md) + * [2.7. 静态库和动态库](ch2-cgo/ch2-07-dll.md) + * [2.8. 例子: 封装LevelDB](ch2-cgo/ch2-08-leveldb.md) + * [2.9. 补充说明](ch2-cgo/ch2-09-faq.md) * [附录](appendix/readme.md) * [附录A: Go语言常见坑](appendix/appendix-a-trap.md) * [附录B: 参考资料](appendix/appendix-b-ref.md) diff --git a/ch2-cgo/ch2-01-hello-cgo.md b/ch2-cgo/ch2-01-hello-cgo.md new file mode 100644 index 0000000..d498414 --- /dev/null +++ b/ch2-cgo/ch2-01-hello-cgo.md @@ -0,0 +1,132 @@ +# 2.1. 你好, CGO! + +在第一章的“Hello, World 的革命”一节中，我们已经见过一个CGO程序。这一节我们重新将给出三个版本的CGO实现，简单展示CGO的用法。 + +## 基于C标准库 + +第一章那个CGO程序还不够简单，我们现在看看更简单的版本： + +```go +package main + +//#include +import "C" + +func main() { + C.puts(C.CString("Hello, World\n")) +} +``` + +我们通过`import "C"`语句启用CGO特性，同时包含C语言的``头文件。然后通过CGO包的`C.CString`函数将Go语言字符串转为C语言字符串，然后调用C语言的`C.puts`函数向标准输出窗口打印转换后的C字符串。 + +相比“Hello, World 的革命”一节中的CGO程序最大的不同是：我们没有在程序退出前释放`C.CString`创建的C语言字符串；还有我们改用`puts`函数直接向标准输出打印，之前是采用`fputs`向标准输出打印。 + +没有释放`C.CString`创建的C语言字符串似乎会导致内存泄露。但是对于这个小程序是没有问题的，因为程序退出后操作系统会自动回收程序的所有资源。 + +## 使用自己的C函数 + +前面我们使用的标准库中已有的函数。我们现在用一个叫`SayHello`的C函数来实现打印，然后从Go语言环境中调用这个`SayHello`函数： + +```go +package main + +/* +#include + +static void SayHello(const char* s) { + puts(s); +} +*/ +import "C" + +func main() { + C.SayHello(C.CString("Hello, World\n")) +} +``` + +除了`SayHello`函数是我们自己实现的，其它的部分和前面的例子一本相似。 + +我们也可以将`SayHello`函数放到当前目录下一个C语言源文件中（后缀名必须是`.c`）。因为是放到独立的C文件中，需要去掉函数的`static`修饰符。 + +```c +// hello.c + +#include + +void SayHello(const char* s) { + puts(s); +} +``` + +然后在CGO部分先声明`SayHello`函数，其它部分不变： + +```go +package main + +//void SayHello(const char* s); +import "C" + +func main() { + C.SayHello(C.CString("Hello, World\n")) +} +``` + +既然`SayHello`函数已经放到独立的C文件中了，我们自然可以先将对应的C文件编译打包为静态库或东塔库文件使用。如果是以静态库或东塔库方式引用`SayHello`函数的话，需要将对应的C源文件移出当前目录（CGO构建程序会自动构建当前目录下的C源文件，从而导致C函数名冲突）。关于静态库等细节在稍后章节讲解。 + +## 用Go来实现C函数 + +其实CGO不仅仅用于Go语言中调用C语言函数，还可以用于导出Go语言函数给C语言函数调用。 + +```go +package main + +/* +#include + +void cgoPuts(char* s); + +static void SayHello(const char* s) { + cgoPuts(s); +} +*/ +import "C" + +func main() { + C.SayHello(C.CString("Hello, World\n")) +} + +//export cgoPuts +func cgoPuts(s *C.char) { + fmt.Print(C.GoString(s)) +} +``` + +我们通过CGO的`//export cgoPuts`指令将Go语言实现的函数`cgoPuts`导出给C语言函数使用。然后在C语言版本的`SayHello`函数中，用`cgoPuts`替换之前的`puts`函数调用。在使用之前，同样要先声明`cgoPuts`函数。 + +需要主要的是，这里其实有两个版本的`cgoPuts`函数：一个Go语言环境的；另一个是C语言环境的。在C语言环境中，`SayHello`调用的也是C语言环境的`cgoPuts`函数；这是CGO自动生成的桥接函数，内部会调用Go语言环境的`cgoPuts`函数。因此，我们也可以直接在Go语言环境中调用C语言环境的`cgoPuts`函数。 + +我们现在可以改用Go语言重新实现C语言接口的`SayHello`函数，然后在`main`函数中还是和之前一样调用`C.SayHello`实现输出： + +```go +package main + +//void SayHello(char* s); +import "C" + +import ( + "fmt" +) + +func main() { + C.SayHello(C.CString("Hello, World\n")) +} + +//export SayHello +func SayHello(s *C.char) { + fmt.Print(C.GoString(s)) +} +``` + +虽然看起来全部是Go语言代码，但是执行的时候是先从Go语言的`main`函数，到CGO自动生成的C语言版本`SayHello`桥接函数，最好又回到了Go语言环境的`SayHello`函数。虽然看起来有点绕，但CGO确实是这样运行的。 + +需要注意的是，CGO导出Go语言函数时，函数参数中不再支持C语言中`const`修饰符。 diff --git a/ch2-cgo/ch2-02-cgo-types.md b/ch2-cgo/ch2-02-cgo-types.md new file mode 100644 index 0000000..e7c3b81 --- /dev/null +++ b/ch2-cgo/ch2-02-cgo-types.md @@ -0,0 +1,347 @@ +# 2.2. 基础类型转换 + +顾名思义，CGO最初是为了利用C语言资源、是C语言到Go语言、从Go语言函数调用C语言函数的意思。当然，最初因为C语言还会涉及回调函数，自然也会涉及到从C语言函数调用Go语言函数。现在，CGO已经演变为C语言和Go语言双向通讯的桥梁，它连接了C语言和Go语言两大编程语言。要想利用好CGO特性，自然需要了解C语言类型和Go语言类型之间的转换，这是本节要讨论的问题。 + +## 数值类型 + +Go语言中访问C语言的符号时，一般是通过虚拟的“C”包访问，比如`C.int`对应C语言的`int`类型。但是，有些C语言的类型是由多个关键字组成，通过虚拟的“C”包访问C语言类型时名称部分不能有空格字符，比如C语言的`unsigned int`不能直接通过`C.unsigned int`访问。CGO对基础的数值类型都提供了对应规则，比如`C.uint`对应C语言的`unsigned int`。 + +Go语言中数值类型和C语言数据类型基本上是相似的，以下是它们的对应关系表。 + +C语言类型 | CGO类型 | Go语言类型 +---------------------- | ----------- | --------- +char | C.char | byte +singed char | C.schar | int8 +unsigned char | C.uchar | uint8 +short | C.short | int16 +unsigned short | C.short | uint16 +int | C.int | int32 +unsigned int | C.uint | uint32 +long | C.long | int32 +unsigned long | C.ulong | uint32 +long long int | C.longlong | int64 +unsigned long long int | C.ulonglong | uint64 +float | C.float | float32 +double | C.double | float64 +size_t | C.size_t | uint + +需要注意的是，虽然C语言中`int`、`short`等类型没有明确定义内存大小，但是它们在CGO中的内存大小是确定的。在CGO中，C语言的`int`和`long`类型都是对应4个字节的内存大小，`size_t`类型可以当作Go语言`uint`无符号整数类型对待。 + +CGO中，虽然C语言的`int`固定为4字节的大小，但是Go语言自己的`int`和`uint`则在32位和64位系统下分别对应4个字节和8个字节大小。如果需要在C语言中访问Go语言的`int`类型，可以通过`GoInt`类型访问，`GoInt`类型在CGO工具生成的`_cgo_export.h`头文件中定义。其实在`_cgo_export.h`头文件中，每个基本的Go数值类型都定义了对应的C语言类型，它们一般都是以单词Go为前缀。下面是64位环境下，`_cgo_export.h`头文件生成的Go数值类型的定义，其中`GoInt`和`GoUint`类型分别对应`GoInt64`和`GoUint64`： + +```c +typedef signed char GoInt8; +typedef unsigned char GoUint8; +typedef short GoInt16; +typedef unsigned short GoUint16; +typedef int GoInt32; +typedef unsigned int GoUint32; +typedef long long GoInt64; +typedef unsigned long long GoUint64; +typedef GoInt64 GoInt; +typedef GoUint64 GoUint; +typedef float GoFloat32; +typedef double GoFloat64; +``` + +除了`GoInt`和`GoUint`之外，我们并不推荐直接访问`GoInt32`、`GoInt64`等类型。更好的做法是通过C语言的C99标准引入的``头文件。在``文件中，它是为了提高C语言的可移植性，每个数值类型都提供了明确内存大小，而且和Go语言的类型命名更加一致。 + +C语言类型 | CGO类型 | Go语言类型 +-------- | ---------- | --------- +int8_t | C.int8_t | int8 +uint8_t | C.uint8_t | uint8 +int16_t | C.int16_t | int16 +uint16_t | C.uint16_t | uint16 +int32_t | C.int32_t | int32 +uint32_t | C.uint32_t | uint32 +int64_t | C.int64_t | int64 +uint64_t | C.uint64_t | uint64 + +前文说过，如果C语言的类型是由多个关键字组成，无法通过虚拟的“C”包直接访问。比如C语言的`unsigned short`不能直接通过`C.unsigned short`访问。但是，在``中通过使用C语言的`typedef`关键字将`unsigned short`重新定义为`uint16_t`一个单词的类型后，我们就可以通过`C.uint16_t`访问原来的`unsigned short`类型了。对于比较复杂的C语言类型，推荐使用`typedef`关键字提高一个规则的类型命名，这样更利于在CGO中访问。 + +## 结构体、联合、枚举类型 + +C语言的结构体、联合、枚举类型不能作为匿名成员被嵌入到Go语言的结构体中。在Go语言中，我们可以通过`C.struct_xxx`来访问C语言中定义的`struct xxx`结构体类型。结构体的内存布局按照C语言的通用对齐规则，在32位Go语言环境C语言结构体也按照32位对齐规则，在64位Go语言环境按照64位的对齐规则。对于指定了特殊对齐规则的结构体，无法在CGO中访问。 + +结构体的简单用法如下： + +```go +/* +struct A { + int i; + float f; +}; +*/ +import "C" +import "fmt" + +func main() { + var a C.struct_A + fmt.Println(a.i) + fmt.Println(a.f) +} +``` + +如果结构体的成员名字中有的是Go语言的关键字，可以通过在成员名开头添加下划线来访问： + +```go +/* +struct A { + int type; // type 是 Go 语言的关键字 +}; +*/ +import "C" +import "fmt" + +func main() { + var a C.struct_A + fmt.Println(a._type) // _type 对应 type +} +``` + +但是如果有2个成员：一个是以Go语言关键字命名，另一个刚好是以下划线和Go语言关键字命名命名，那么以Go语言关键字命名将无法访问（被屏蔽）： + +```go +/* +struct A { + int type; // type 是 Go 语言的关键字 + float _type; // 将屏蔽CGO对 type 成员的访问 +}; +*/ +import "C" +import "fmt" + +func main() { + var a C.struct_A + fmt.Println(a._type) // _type 对应 _type +} +``` + +C语言结构体中位字段对应的成员无法在Go语言中访问，如果需要操作位字段成员，需要通过在C语言中定义辅助函数来完成。对应零长数组的成员，无法在Go语言中直接访问数组的元素。其中零长的数组成员所在位置的偏移量依然可以通过`unsafe.Offsetof(a.arr)`来访问。 + +```go +/* +struct A { + int size: 10; // 位字段无法访问 + float arr[]; // 零长的数组也无法访问 +}; +*/ +import "C" +import "fmt" + +func main() { + var a C.struct_A + fmt.Println(a.size) // 错误: 位字段无法访问 + fmt.Println(a.arr) // 错误: 零长的数组也无法访问 +} +``` + +在C语言中，我们无法直接访问Go语言定义的结构体类型。 + +对于联合类型，我们可以通过`C.union_xxx`来访问C语言中定义的`union xxx`类型。但是Go语言中并不支持C语言联合类型，它们会被转为对应大小的字节数组。 + +```go +/* +#include + +union B1 { + int i; + float f; +}; + +union B2 { + int8_t i8; + int64_t i64; +}; +*/ +import "C" +import "fmt" + +func main() { + var b1 C.union_B1; + fmt.Printf("%T\n", b1) // [4]uint8 + + var b2 C.union_B2; + fmt.Printf("%T\n", b2) // [8]uint8 +} +``` + +如果需要操作C语言的联合类型变量一般有三种方法：第一种是在C语言中定义辅助函数来完成；第二种是通过Go语言的"encoding/binary"手工解码成员，但是需要主要大端小端问题；第三种是使用`unsafe`包强制转型为对应类型后访问，这是性能最好的方式。下面是通过`unsafe`包访问联合类型成员的方式： + +```go +/* +#include + +union B { + int i; + float f; +}; +*/ +import "C" +import "fmt" + +func main() { + var b C.union_B; + fmt.Println("b.i:", *(*C.int)(unsafe.Pointer(&b))) + fmt.Println("b.f:", *(*C.float)(unsafe.Pointer(&b))) +} +``` + +虽然`unsafe`包访问最简单、性能也最好，但是对于有嵌套联合类型的情况处理会导致问题复杂化。对于复杂的联合类型，推荐通过在C语言中定义辅助函数的方式处理。 + +对于枚举类型，我们可以通过`C.enum_xxx`来访问C语言中定义的`enum xxx`结构体类型。 + +```go +/* +enum C { + ONE, + TWO, +} +*/ +import "C" +import "fmt" + +func main() { + var c C.enum_C = C.TWO + fmt.Println(c) + fmt.Println(C.ONE) + fmt.Println(C.TWO) +} +``` + +在C语言中，枚举类型底层对应`int`类型，支持负数类型的值。我们可以通过`C.ONE`、`C.TWO`等直接访问定义的枚举值。 + +## 数组、字符串和切片 + +在C语言中，数组名其实对应一个指针，指向特定类型特定长度的一段内存，但是这个指针不能被修改；当把数组名传递给一个函数时，实际上传递的是数组第一个元素的地址。为了讨论方便，我们将一段特定长度的内存统称为数组。C语言的字符串是一个char类型的数组，字符串的长度需要根据表示结尾的NULL字符的位置确定。C语言中没有切片类型。 + +在Go语言中，数组是一种值类型，而且数组的长度是数组类型的一个部分。Go语言字符串对应一段长度确定的只读byte类型的内存。Go语言的切片则是一个简化版的动态数组。 + + +Go语言和C语言的数组、字符串和切片之间的相互转换可以简化为Go语言的切片和C语言中指向一定长度内存的指针之间的转换。 + +CGO的C虚拟包提供了以下一组函数，用于Go语言和C语言之间数组和字符串的双向转换： + +```go +// Go string to C string +// The C string is allocated in the C heap using malloc. +// It is the caller's responsibility to arrange for it to be +// freed, such as by calling C.free (be sure to include stdlib.h +// if C.free is needed). +func C.CString(string) *C.char + +// Go []byte slice to C array +// The C array is allocated in the C heap using malloc. +// It is the caller's responsibility to arrange for it to be +// freed, such as by calling C.free (be sure to include stdlib.h +// if C.free is needed). +func C.CBytes([]byte) unsafe.Pointer + +// C string to Go string +func C.GoString(*C.char) string + +// C data with explicit length to Go string +func C.GoStringN(*C.char, C.int) string + +// C data with explicit length to Go []byte +func C.GoBytes(unsafe.Pointer, C.int) []byte +``` + +其中`C.CString`针对输入的Go字符串，克隆一个C语言格式的字符串；返回的字符串由C语言的`malloc`函数分配，不需要时可以通过C语言的`free`函数释放。`C.CBytes`函数的功能和`C.CString`类似，用于将输入的Go语言字节切片克隆一个C语言版本的字节数组，返回的C语言数组不需要时可以通过`free`函数释放。`C.GoString`用于将以NULL结尾的C语言字符串克隆一个Go语言字符串。`C.GoStringN`用于将一个字符数组克隆一个Go语言字符串。`C.GoBytes`用于将C语言数组，克隆一个Go语言字节切片。 + +该组辅助函数都是以克隆的方式运行。当Go语言字符串和切片向C语言转换时，克隆的内存由C语言的`malloc`函数分配，最终可以通过`free`函数释放。当C语言字符串或数组向Go语言转换时，克隆的内存由Go语言分配管理。通过该组转换函数，转换前和转换后的内存依然在各自的语言环境中，它们并没有跨越Go语言和C语言。克隆方式实现转换的优点是接口和内存管理都很简单，缺点是克隆需要分配新的内存和复制操作都会导致额外的开销。 + +在`reflect`包中有字符串和切片的定义： + +```go +type StringHeader struct { + Data uintptr + Len int +} + +type SliceHeader struct { + Data uintptr + Len int + Cap int +} +``` + +如果不希望单独分配内存，可以在Go语言中直接访问C语言的内存空间： + +```go +/* +static char arr[10]; +static char *s = "Hello"; +*/ +import "C" +import "fmt" + +func main() { + // 通过 reflect.SliceHeader 转换 + var arr0 []byte + var arr0Hdr = (*reflect.SliceHeader)(unsafe.Pointer(&arr0)) + arr0Hdr.Data = uintptr(unsafe.Pointer(&C.arr[0])) + arr0Hdr.Len = 10 + arr0Hdr.Cap = 10 + + // 通过切片语法转换 + arr1 := (*[31]byte)(unsafe.Pointer(&C.arr[0]))[:10:10] + + var s0 string + var s0Hdr := (*reflect.StringHeader)(unsafe.Pointer(&s0)) + s0Hdr.Data = uintptr(unsafe.Pointer(C.s)) + s0Hdr.Len = int(C.strlen(C.s)) + + sLen := int(C.strlen(C.s)) + s1 := string((*[31]byte)(unsafe.Pointer(&C.s[0]))[:sLen:sLen]) +} +``` + +因为Go语言的字符串是只读的，用户需要自己保证Go字符串在使用期间，底层对应的C字符串内容不会发生变化、内存不会被提前释放掉。 + +在CGO中，会为字符串和切片生成和上面结构对应的C语言版本的结构体： + +```c +typedef struct { const char *p; GoInt n; } GoString; +typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; +``` + +在C语言中可以通过`GoString`和`GoSlice`来访问Go语言的字符串和切片。如果是Go语言中数组类型，可以将数组转为切片后再行转换。如果字符串或切片对应的底层内存空间由Go语言的运行时管理，那么在C语言中不能长时间保存Go内存对象。 + +```go +// 例子 +// 字符串和切片 +// 作为参数或返回值 和 C 函数通信 +``` + +关于CGO内存模型的细节在稍后章节中会详细讨论。 + +## 指针和切片 + +C语言和Go语言指针的转换可以看做是两中不同类型的指针之间的转换。在Go语言中我们无法在不同类型之间做转换，不同类型的指针也是由此限制。但是任意类型的指针均可以和`unsafe.Pointer`相互转换，我们可以以`unsafe.Pointer`作为中间桥接类型实现不同类型指针之间的转换。 + +```go +var p *X +var q *Y + +q = (*Y)(unsafe.Pointer(p)) // *X => *Y +p = (*X)(unsafe.Pointer(q)) // *Y => *X +``` + +再结合`reflect.SliceHeader`类型，我们可以实现`[]X`和`[]Y`类型的切片转换： + +```go +var p []X +var q []Y + +pHdr := (*reflect.SliceHeader)(unsafe.Pointer(&p)) +qHdr := (*reflect.SliceHeader)(unsafe.Pointer(&q)) + +pHdr.Data = qHdr.Data +pHdr.Len = qHdr.Len * unsafe.Sizeof(q[0]) / unsafe.Sizeof(p[0]) +pHdr.Cap = qHdr.Cap * unsafe.Sizeof(q[0]) / unsafe.Sizeof(p[0]) +``` + +如果X和Y类型的大小不同，需要重新即使Len和Cap属性。需要注意的是，如果X或Y是空类型，上述代码中可能导致除0的问题，实际代码需要根据情况酌情处理。 + +针对CGO中常用的功能，作者封装了 "github.com/chai2010/cgo" 包，提供基本的转换功能，具体的细节可以参考实现代码。 diff --git a/ch2-cgo/ch2-03-basic.md b/ch2-cgo/ch2-03-basic.md new file mode 100644 index 0000000..bfcae69 --- /dev/null +++ b/ch2-cgo/ch2-03-basic.md @@ -0,0 +1,3 @@ +# 2.3. CGO编程基础 + +TODO diff --git a/ch2-cgo/ch2-04-memory.md b/ch2-cgo/ch2-04-memory.md new file mode 100644 index 0000000..2b576f5 --- /dev/null +++ b/ch2-cgo/ch2-04-memory.md @@ -0,0 +1,3 @@ +# 2.4. CGO内存模型 + +TODO diff --git a/ch2-cgo/ch2-05-class.md b/ch2-cgo/ch2-05-class.md new file mode 100644 index 0000000..08ba95a --- /dev/null +++ b/ch2-cgo/ch2-05-class.md @@ -0,0 +1,3 @@ +# 2.5. C++ 类类包装 + +TODO diff --git a/ch2-cgo/ch2-06-build.md b/ch2-cgo/ch2-06-build.md new file mode 100644 index 0000000..94bbd1d --- /dev/null +++ b/ch2-cgo/ch2-06-build.md @@ -0,0 +1,3 @@ +# 2.6. 命令行工具和构建参数 + +TODO diff --git a/ch2-cgo/ch2-07-dll.md b/ch2-cgo/ch2-07-dll.md new file mode 100644 index 0000000..f28f2ba --- /dev/null +++ b/ch2-cgo/ch2-07-dll.md @@ -0,0 +1,4 @@ +# 2.7 静态库和动态库 + +TODO + diff --git a/ch2-cgo/ch2-08-leveldb.md b/ch2-cgo/ch2-08-leveldb.md new file mode 100644 index 0000000..9c22f0f --- /dev/null +++ b/ch2-cgo/ch2-08-leveldb.md @@ -0,0 +1,3 @@ +# 2.8. 封装LevelDB + +TODO diff --git a/ch2-cgo/ch2-09-faq.md b/ch2-cgo/ch2-09-faq.md new file mode 100644 index 0000000..bced967 --- /dev/null +++ b/ch2-cgo/ch2-09-faq.md @@ -0,0 +1,3 @@ +# 2.9. 补充说明 + +TODO diff --git a/ch2-cgo/readme.md b/ch2-cgo/readme.md new file mode 100644 index 0000000..304e6c3 --- /dev/null +++ b/ch2-cgo/readme.md @@ -0,0 +1,3 @@ +# 第二章 CGO编程 + +C/C++经过几十年的发展，已经积累了庞大的软件资产，它们很多久经考验而且性能已经足够优化。Go语言必须能够站在C/C++这个巨人的肩膀之上，有了海量的C/C++软件资产兜底之后，我们才可以放心愉快地用Go语言编程。C语言作为一个通用语言，很多库会选择提供一个C兼容的API，然后用其他不同的编程语言实现。Go语言通过自带的一个叫CGO的工具来支援C语言函数调用，同时我们可以用Go语言导出C东塔库接口给其它语言使用。本章主要讨论CGO编程中涉及的一些问题。