包内容
Pointer与uintptr
uintptr是一个整数类型。
- 即使uintptr变量仍然有效，由uintptr变量表示的地址处的数据也可能被GC回收。
unsafe.Pointer是一个指针类型。
- 但是unsafe.Pointer值不能被取消引用。
- 如果unsafe.Pointer变量仍然有效，则由unsafe.Pointer变量表示的地址处的数据不会被GC回收。
- unsafe.Pointer是一个通用的指针类型，就像* int等。
Pointer
Pointer可代替任意类型的指针。这里有四种特殊的操作对于Pointer是被允许的：
- 任何类型的指针值都可以转换为unsafe.Pointer。
- unsafe.Pointer可以转换为任何类型的指针值。
- uintptr可以转换为unsafe.Pointer。
- unsafe.Pointer可以转换为uintptr。
这使得允许Pointer破坏系统强类型的规则,对任意指针进行读写。所以使用的时候要极其的小心。
Pointer represents a pointer to an arbitrary type. There are four special operations available for type Pointer that are not available for other types:
- A pointer value of any type can be converted to a Pointer.
- A Pointer can be converted to a pointer value of any type.
- A uintptr can be converted to a Pointer.
- A Pointer can be converted to a uintptr.
Pointer therefore allows a program to defeat the type system and read and write
arbitrary memory. It should be used with extreme care.
实例
1、使用Pointer尽心任意类型的转换
func Float64bits(f float64) uint64 {
return *(*uint64)(unsafe.Pointer(&f))
}
2、Pointer与unitptr的相互转化
Pointer——>uintptr：
var a = 1
u := uintptr(unsafe.Pointer(&a))
fmt.Println(u)
需要注意的是，转化之后的uintptr是一个整数，并不是引用，没有任何的指针特性，单纯的一个数而已。只是这个数是一个地址的值。通常在调试程序是，打印这个值。由于uintptr是一个数，因此可以对其做加减等数学运算。
// 等价于：e := unsafe.Pointer(&x[i])
e := unsafe.Pointer(uintptr(unsafe.Pointer(&x[0])) + i*unsafe.Sizeof(x[0]))
uintptr-->Pointer:
错误示范：
// INVALID: uintptr cannot be stored in variable before conversion back to Pointer.
u := uintptr(p)
p = unsafe.Pointer(u + offset)
正确的写法：
p = unsafe.Pointer(uintptr(p) + offset)
Sizeof方法介绍
以字节为单位，返回任意类型的大小，但是这个大小不包括任何的指针指向的内容的大小，只是对象本身所占用的内存空间的字节数。例如slice那么只会返回slice结构体本身的大小24字节，而不会包括，slice中array真正指向的内容部分的大小。
var a int32
var b = `abcdefghijklmnopqfdsfdsfdsafdsfdsafdsfdsfdsfdsfds`
var c = [10]int{1,2,3}
var d = []int{1,2,3,4,5}
var f = 'a'
fmt.Println(unsafe.Sizeof(a)) // 4
fmt.Println(unsafe.Sizeof(b)) // 16
fmt.Println(unsafe.Sizeof(c)) // 80
fmt.Println(unsafe.Sizeof(d)) // 24
fmt.Println(unsafe.Sizeof(f)) // 4
/*
type slice struct {
array unsafe.Pointer
len int
cap int
}
*/
Offsetof方法介绍
// Offsetof returns the offset within the struct of the field represented by x,
// which must be of the form structValue.field. In other words, it returns the
// number of bytes between the start of the struct and the start of the field.
// 实例一：
type B struct {
Name string
Age int
Score int
}
func Offsetof() {
b := &B{}
fmt.Println(unsafe.Offsetof(b.Name)) // 0
fmt.Println(unsafe.Offsetof(b.Age)) // 16
fmt.Println(unsafe.Offsetof(b.Score)) // 24
}
// 实例二：
type Num struct{
i string
j int64
}
func main(){
n := Num{i: "EDDYCJY", j: 1}
nPointer := unsafe.Pointer(&n)
niPointer := (*string)(unsafe.Pointer(nPointer))
*niPointer = "煎鱼"
njPointer := (*int64)(unsafe.Pointer(uintptr(nPointer) + unsafe.Offsetof(n.j)))
*njPointer = 2
fmt.Printf("n.i: %s, n.j: %d", n.i, n.j)
}
应用
// 应用：修改其他包中的私有变量
// 方法1：定义一个与其他包中一样的结构体，利用unsafe.Pointer转换成自己定义的结构体指针，然后直接修改
type Reader struct {
s string
i int64 // current reading index
prevRune int // index of previous rune; or < 0
}
func Apply1() {
str := "abcdefghijklmn"
reader := strings.NewReader(str)
uReader := (*Reader)(unsafe.Pointer(reader))
by, _ := reader.ReadByte()
fmt.Println(by)
uReader.i = 0
rune, size, _ := reader.ReadRune()
fmt.Println(rune, size)
}
// 方法2: 使用reflect中字段的StructField 中的offset + 结构体对象的指针值
func Apply2() {
sr := strings.NewReader("abcdef")
// 但是我们可以通过 unsafe 来进行修改
// 先将其转换为通用指针
// 确定要修改的字段（这里不能用 unsafe.Offsetof 获取偏移量，因为是私有字段）
if sf, ok := reflect.TypeOf(*sr).FieldByName("i"); ok {
// 偏移到指定字段的地址
up := uintptr(unsafe.Pointer(sr)) + sf.Offset
// 转换为通用指针
p := unsafe.Pointer(up)
// 转换为相应类型的指针
pi := (*int64)(p)
// 对指针所指向的内容进行修改
*pi = 3 // 修改索引
}
// 看看修改结果
fmt.Println(sr)
// 看看读出的是什么
b, err := sr.ReadByte()
fmt.Printf("%c, %v\n", b, err)
}
总结
1、介绍了unsafe包的主要作用
2、Pointer、uintptr的作用以及相互转化
3、Sizeof，Offsetof方法的介绍
4、应用实例
