golang: 利用unsafe操做未导出变量

看了 @喻恒春 大神的利用unsafe.Pointer来突破私有成员，以为例子举得不太好。并且不该该简单的放个demo，至少要讲一下其中的原理，让看的童鞋明白因此然。see：http://my.oschina.net/achun/blog/122540

unsafe.Pointer其实就是相似C的void *，在golang中是用于各类指针相互转换的桥梁。uintptr是golang的内置类型，是能存储指针的整型，uintptr的底层类型是int，它和unsafe.Pointer可相互转换。uintptr和unsafe.Pointer的区别就是：unsafe.Pointer只是单纯的通用指针类型，用于转换不一样类型指针，它不能够参与指针运算；而uintptr是用于指针运算的，GC 不把 uintptr 当指针，也就是说 uintptr 没法持有对象，uintptr类型的目标会被回收。golang的unsafe包很强大，基本上不多会去用它。它能够像C同样去操做内存，但因为golang不支持直接进行指针运算，因此用起来稍显麻烦。

切入正题。利用unsafe包，可操做私有变量(在golang中称为“未导出变量”，变量名以小写字母开始)，下面是具体例子。

在$GOPATH/src下创建poit包，并在poit下创建子包p，目录结构以下：

$GOPATH/src

----poit

--------p

------------v.go

--------main.go

如下是v.go的代码：

package p

import (
    "fmt"
)

type V struct {
    i int32
    j int64
}

func (this V) PutI() {
    fmt.Printf("i=%d\n", this.i)
}

func (this V) PutJ() {
    fmt.Printf("j=%d\n", this.j)
}

意图很明显，我是想经过unsafe包来实现对V的成员i和j赋值，而后经过PutI()和PutJ()来打印观察输出结果。

如下是main.go源代码：

package main

import (
    "poit/p"
    "unsafe"
)

func main() {
    var v *p.V = new(p.V)
    var i *int32 = (*int32)(unsafe.Pointer(v))
    *i = int32(98)
    var j *int64 = (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Sizeof(int32(0)))))
    *j = int64(763)
    v.PutI()
    v.PutJ()
}

固然会有些限制，好比须要知道结构体V的成员布局，要修改的成员大小以及成员的偏移量。咱们的核心思想就是：结构体的成员在内存中的分配是一段连续的内存，结构体中第一个成员的地址就是这个结构体的地址，您也能够认为是相对于这个结构体偏移了0。相同的，这个结构体中的任一成员均可以相对于这个结构体的偏移来计算出它在内存中的绝对地址。

具体来说解下main方法的实现：

var v *p.V = new(p.V)

new是golang的内置方法，用来分配一段内存(会按类型的零值来清零)，并返回一个指针。因此v就是类型为p.V的一个指针。

var i *int32 = (*int32)(unsafe.Pointer(v))

将指针v转成通用指针，再转成int32指针。这里就看到了unsafe.Pointer的做用了，您不能直接将v转成int32类型的指针，那样将会panic。刚才说了v的地址其实就是它的第一个成员的地址，因此这个i就很显然指向了v的成员i，经过给i赋值就至关于给v.i赋值了，可是别忘了i只是个指针，要赋值得解引用。

*i = int32(98)

如今已经成功的改变了v的私有成员i的值，好开心^_^

可是对于v.j来讲，怎么来获得它在内存中的地址呢？其实咱们能够获取它相对于v的偏移量(unsafe.Sizeof能够为咱们作这个事)，但我上面的代码并无这样去实现。各位别急，一步步来。

var j *int64 = (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Sizeof(int32(0)))))

其实咱们已经知道v是有两个成员的，包括i和j，而且在定义中，i位于j的前面，而i是int32类型，也就是说i占4个字节。因此j是相对于v偏移了4个字节。您能够用uintptr(4)或uintptr(unsafe.Sizeof(int32(0)))来作这个事。unsafe.Sizeof方法用来获得一个值应该占用多少个字节空间。注意这里跟C的用法不同，C是直接传入类型，而golang是传入值。之因此转成uintptr类型是由于须要作指针运算。v的地址加上j相对于v的偏移地址，也就获得了v.j在内存中的绝对地址，别忘了j的类型是int64，因此如今的j就是一个指向v.j的指针，接下来给它赋值：

*j = int64(763)

好吧，如今貌视一切就绪了，来打印下：

v.PutI()
v.PutJ()

若是您看到了正确的输出，那恭喜您，您作到了！

可是，别忘了上面的代码实际上是有一些问题的，您发现了吗？

在p目录下新建w.go文件，代码以下：

package p

import (
    "fmt"
    "unsafe"
)

type W struct {
    b byte
    i int32
    j int64
}

func init() {
    var w *W = new(W)
    fmt.Printf("size=%d\n", unsafe.Sizeof(*w))
}

须要修改main.go的代码吗？不须要，咱们只是来测试一下。w.go里定义了一个特殊方法init，它会在导入p包时自动执行，别忘了咱们有在main.go里导入p包。每一个包均可定义多个init方法，它们会在包被导入时自动执行(在执行main方法前被执行，一般用于初始化工做)，可是，最好在一个包中只定义一个init方法，不然您或许会很难预期它的行为)。咱们来看下它的输出：

size=16

等等，好像跟咱们想像的不一致。来手动计算一下：b是byte类型，占1个字节；i是int32类型，占4个字节；j是int64类型，占8个字节，1+4+8=13。这是怎么回事呢？这是由于发生了对齐。在struct中，它的对齐值是它的成员中的最大对齐值。每一个成员类型都有它的对齐值，能够用unsafe.Alignof方法来计算，好比unsafe.Alignof(w.b)就能够获得b在w中的对齐值。同理，咱们能够计算出w.b的对齐值是1，w.i的对齐值是4，w.j的对齐值也是4。若是您认为w.j的对齐值是8那就错了，因此咱们前面的代码能正确执行(试想一下，若是w.j的对齐值是8，那前面的赋值代码就有问题了。也就是说前面的赋值中，若是v.j的对齐值是8，那么v.i跟v.j之间应该有4个字节的填充。因此获得正确的对齐值是很重要的)。对齐值最小是1，这是由于存储单元是以字节为单位。因此b就在w的首地址，而i的对齐值是4，它的存储地址必须是4的倍数，所以，在b和i的中间有3个填充，同理j也须要对齐，但由于i和j之间不须要填充，因此w的Sizeof值应该是13+3=16。若是要经过unsafe来对w的三个私有成员赋值，b的赋值同前，而i的赋值则须要跳过3个字节，也就是计算偏移量的时候多跳过3个字节，同理j的偏移能够经过简单的数学运算就能获得。

好比也能够经过unsafe来灵活取值：

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var b []byte = []byte{'a', 'b', 'c'}
    var c *byte = &b[0]
    fmt.Println(*(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(c)) + uintptr(1))))
}

关于填充，FastCGI协议就用到了。