swig不能直接使用官方的程序，而必须打一个patch 后才能使用。svn下载swig源代码后（看版本号应该是2.0.5了），打上
swig_go_windows2.patch
这个patch。至于怎么打patch，请自行Google之。

swig的编译也是比较折腾的。因为他依赖 yodl2man yodl2html这东西，而这东西又依赖 icmake，不过后来发现这东西不要也行，虽然 swig在 make install的时候没有完全结束，但是生成的东西，已经够用了。

把C写的库包装为 GO包。

首先需要准备两个文件 test.i test.c

$ cat test.c
#include 
double MyVar = 3.0;

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

int MyMod(int x, int y) {
    return (x % y);
}

char *GetTime() {
    time_t ltime;
    time(&ltime);
    return ctime(&ltime);
}

$ cat test.i
%module test
%{
    extern double MyVar;
    extern int Fact(int n);
    extern int MyMod(int x, int y);
    extern char *GetTime();
%}

extern double MyVar;
extern int Fact(int n);
extern int MyMod(int x, int y);
extern char *GetTime();

需要注意的是 C中的如果要想在Go中可以调用 ，首字母必须要 大写。开始 swig

//初始
$ ls
test.i test.c
//使用swig生成需要的文件
$ swig -go -windows test.i
$ ls
test.c  test.go  test.i  test_dllmain.cxx  test_gc.c  test_wrap.c
//分别编译 test.c test_wrap.c test_dllmain.cxx 为目标文件 *.o
$ gcc -c test.c test_wrap.c test_dllmain.cxx
//将上一步编译的结果链接成一个动态链接库
$ gcc -shared test.o test_wrap.o test_dllmain.o -o test.dll
//编译 test.go
$ 8g test.go
//编译 test_gc.c
$ 8c -I "go的pkg目录" test_gc.c
//将test.8 test_gc.8 打包成go库，就是一个静态库，相当于gcc里面使用 ar 命令打包一样。
$ gopack grc test.a test.8 test_gc.8

至此万事俱备了。写个go 程序来试试。

$ cat main.go
package main

import "./test"
import "fmt"

func main() {
    println(test.Fact(5))
    //println(test.MyVar)   //不能直接调用必须使用 getter setter来调用如下
    test.SetMyVar(99)      //来设置 MyVar的值
    fmt.Printf("%f
", test.GetMyVar())   //取得刚设置的值。
    println(test.MyMod(10, 3))
    println(test.GetTime())
}

$ 8g main.go
$ 8l main.8
$ ./8.out.exe
120
1
Thu Jun 23 04:06:40 2011

现在把 test.dll改名，看看这个程序是不是真调用 了这个动态链接库。

如果要在其它地方使用只需要 test.a 及 test.dll 两个文件 。。test.a就是go的库，这是魔法所在，就是这样东西负责调用 C里面的函数。。因为Go是静态编译，所以编译好的Go程序就不需要 test.a这东西了，只要test.dll带上就行了。。

//引入包
import "container/ring"
//创建闭环，这里创建10个元素的闭环
r := ring.New(10)
//给闭环中的元素附值
for i := 1; i <= r.Len(); i++ {
    r.Value = i
    r = r.Next()
}
//循环打印闭环元素的值，这里的操作方法很像javascript
r.Do(func(p interface{}){
    println(p)
})
//当前元素就是
// r
//当前元素的值就是
// r.Value       //这里是 1
//取得当前元素之后的第5个元素
r5 := r.Move(5)    //这里是 6
//链接 当前元素r与r5，相当于删除了r跟r5之间的元素，使 r.Next() == r5
rl := r.Link(r5)  //这样 r环里有 1 6 7 8 9 10
                    //rl 环路里有  2 3 4 5 

//把rl环加回到 r环原来的位置
//要确保r的当前位置是 1，rl的当前位置为2
rf := r.Link(rl)
//这样 r就变回了 1 2 3 4 5 6 7 8 9 10
//rf则是 从 rl.Next()开始环，内容则与 r的一样。
//6 7 8 9 10 1 2 3 4 5
另外做过一次 Do()循环操作后 闭环的当前位置不变。

package main 

//插入排序
func main() {
    a := []int{5, 4, 3, 2, 1}
    for i := 1; i < len(a); i++ {
        temp := a[i]
        j := i - 1
        for j >= 0 && a[j] > temp {
            a[j + 1] = a[j]
            j--
        }
        a[j + 1] = temp
    }
    for _, v := range a {
        println(v)
    }
}

原理就是依顺找到每个元素在己排充部分中自己的位置，并插入。

package main  

//希尔排序
func main() {
    a := []int{5, 4, 3, 2, 1}
    gap := 0
    for gap * 3 + 1 < len(a) {
    gap = gap * 3 + 1
    }
    for gap > 0 {  //分段 

        for i := gap; i < len(a); i++ {   //对分段进行插入排序
            temp := a[i]
            j := i - gap
            for j >= 0 && a[j] > temp {
                a[j + gap] = a[j]
                j -= gap
            }
            a[j + gap] = temp
        }
        gap = (gap - 1) / 3 

    }
    for _, v := range a {
        println(v)
    }
}

希尔排序就是分段了的插入排序。最大限度地提高每次对比后元素移动的距离。gap = gap * 3 + 1分隔数由实验取得。如 1 4 13之类。反顺减小到 1。

Go语言的结构体中可以包含匿名的字段，比如：

struct {
	T1        // 字段名自动为 T1
	*T2       // 字段名自动为 T2
	P.T3      // 字段名自动为 T3
	*P.T4     // 字段名自动为 T4
	x, y int  // 非匿名字段 x ， y
}

如果结构体 S，包含一个匿名字段 T，那么这个结构体 S 就有了 T的方法。
如果包含的匿名字段为 *T，那么这个结构体 S 就有了 *T 的方法。
如果S包含的匿名字段为 T或*T，那么 *S就有了 *T的方法。

比如

type gzipResponseWriter struct {
    io.Writer
}

因为 io.Writer里有 Write方法，所以 gzipResponseWriter 也有了 Write方法

var g gzipResponseWriter
g.Write(数据)

此处的 g.Write 就相当于 g.Writer.Write(数据)。

那么如果两个匿名字段都有同一个方法的时候，会怎么样呢？

type gzipResponseWriter struct {
    io.Writer
    http.ResponseWriter
}

io.Writer这个接口已经有 Write方法了，http.ResponseWriter 同样有 Write方法。那么对 g.Write写的时候，到底调用哪个呢？是 g.Writer.Write 还是 g.ResponseWriter.Write呢？你不知道程序也不知道，如果编译就出现“Write模糊不清”的错误。

怎么解决这个问题？

其一：就是重写 gzipResponseWriter的 Write方法，指明要写到哪一方。

func (w gzipResponseWriter) Write(b []byte) (int, os.Error) {
    return w.Writer.Write(b)
}

上面这里就是指定使用 io.Writer里面的 Write方法。

其二：使用匿名字段暴露方法优先级来确定重复方法的时候使用哪一个方法，原则就是【简单优先】。所以我们这里把 http.ResponseWriter弄复杂一点，使用另一个结构体先包裹一次。

type responseWriter struct {
    http.ResponseWriter
}

然后再在 gzipResponseWriter里面插入这个结构体

type gzipResponseWriter struct {
	io.Writer
	responseWriter
}

这样就是 io.Writer的方法是会优先暴露出来的。这样就省去了上面那样的麻烦，而且当有多个重复方法的时候，还得一个一个来改写。记得使用 gzipResponseWriter 的时候原来的 类型为 http.ResponseWriter 的对象比如 w，要用 responseWriter{w}，包装一下就可以使用到 gzipResponseWriter里面了。

参考英文及评论内容

写python的时候，有时候懒得一个一个错误去分别处理，直接使用一个整体来try catch来捕获所有异常。如：

try:
	one()
	two()
	three()
except:
	处理异常

Go中的实现方式：

func main() {
        defer func() {
        	if e, ok := recover(); ok {
			println(e.String())  //打印出错误
		}
        }()
        one()
        two()
        three()
        ...
}

这样one two three任何一个执行中的异常都会被前面的这个闭包函数捕获。