直接嵌入c源代码到go代码里面
十多年的承德网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。营销型网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整承德建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联建站从事“承德网站设计”,“承德网站推广”以来，每个客户项目都认真落实执行。
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，所以只能编译成动态链接。
在以下这段代码中，我们操作一个文件，无论成功与否都需要关闭文件句柄。这里在三处不同的位置都调用了file.Close()方法，代码显得非常冗余。
我们利用延迟调用来优化代码。定义后的defer代码，会在return之前返回，让代码显得更加紧凑，且可读性变强，对上面的代码改造如下：
我们通过这个示例来看一下延迟调用与正常代码之间的执行顺序
先简单分析一下代码逻辑：
从输出中，我们可以观察到如下现象：
从这个实例中，我们很明显观察到，defer语句是在return之前执行
如果一个函数内定义了多个defer，则调用顺序为LIFO（后进先出）方式执行。
仍然是相同的例子，但是在TestDefer中我们定义了三个defer输出，根据LIFO原则，输出的顺序是3rd-2nd-1st，根据最后的结果，也是逆向向上执行defer输出。
就在整理这篇笔记的时候，发现了自己的认知误区，主要是本节实例三中发现的，先来看一下英文的描述：
对于上面的这段话的理解：
下面是代码执行输出，我们来一起分析一下：
虽然在a()函数内，显示的返回了10，但是main函数中得到的结果是defer函数自增后的结果，我们来分析一下代码：
在这篇文章的上一版，我曾经尝试用指针取解释defer修改返回值的类型，但是感觉不够透彻，也让阅读者非常困惑，索性参考了一下go官方blog中的一篇文章，在此基础上进行了扩展。如需要阅读原文，可以参考下面的文章。
前段时间，我们实验室用go作为后台开发语言开发了一个web项目，由于这是自己第一次使用go语言进行开发，在开发过程中，一味着追求完成任务，在编码的时候没有太注重性能，虽然勉强实现了功能，但是对go语言的理解还是比较浅显的。下面来谈谈自己对go语言中函数与方法的理解。
普通函数:
go函数可以返回多个值
值传递: 值传递是指在调用函数时将实际参数复制一份传递到函数中，这样函数中如果对参数进行修改，将不会影响到实际参数
引用传递: 引用传递是指在调用函数将实际参数的地址传递到函数中，那么在函数中对参数进行的修改，将影响到实际参数。
一般来说go语言函数的 接收者(也就是形参)一般放在函数名后面 ，不能将指针类型的数据直接传递，也就是说函数形参如果是值类型，调用者必须使用值作为实参过来，如果函数形参是指针类型，则函数调用者需使用指针作为实参来调用。
普通方法:
接收者是在func关键字后面，而不是在函数名称后面，接收者可以是自己定义的一个类型，这个类型可以是struct、interface，一个方法就是一个包含了接收者的函数，接收者可以是命名类型或者是结构体类型的一个值或者是一个指针。
下面是一个例子来说明方法和函数的区别（重点）
按值传递函数参数，是拷贝参数的实际值到函数的形式参数的方法调用。在这种情况下，参数在函数内变化对参数不会有影响。
默认情况下，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
这表明变化的功能以及不同于通过值调用的外部体现的改变不能反映函数之外。