unsafe—内存操作 un-buffered 内存

unsafe包含绕过Go程序类型安全的操作。

导入unsafe的包可能不可移植，并且不受Go 1兼容性指南的保护。

unsafe.Pointer 四种特殊操作

Pointer表示指向任意类型的指针，Pointer类型有四种特殊操作不适用于其他类型：

• 任何类型的指针值都可以转换为Pointer。
• Pointer可以被转换为任何类型的指针值。

i:=unsafe.Pointer(new(interface{}))
*(*int)(i)=2
fmt.Println(*(*int)(i))
//输出：
3

• uintptr可以转换为Pointer。
• Pointer可以转换为uintptr。

因此Pointer可以无视类型系统，读写任意内存，应该特别小心使用。

unsafe.Pointer 六种使用模式

涉及Pointer的以下模式有效：（不使用这些模式的代码目前可能无效或将来无效）

即使是下面的有效模式也有重要的警告。

运行go vet可以帮助找到不符合这些模式的Pointer的使用，但是没有找到不代表代码一定有效

（1）将*T1指针转换为*T2。

如果T2不大于T1并且两者共享等效的内存布局，则此转换允许将一种类型的数据重新解释为另一种类型的数据。

例如math.Float64bits的实现：

func Float64bits(f float64) uint64 {
 return *(*uint64)(unsafe.Pointer(&f))
}

（2）将*Pointer 转换为*uintptr（不转回 *Pointer）

将Pointer转换为uintptr会产生指向内存地址的整数值，这种uintptr的通途通常是用来打印。

通常情况下将uintptr转换回Pointer是无效的，因为uintptr是一个整数，不是引用类型。

将Pointer转换为uintptr会创建一个没有指针语义的整数值。

即使uintptr保存某个对象的地址，如果对象移动，垃圾收集器也不会更新该uintptr的值，uintptr也不会保持该对象不被回收。

其余模式枚举了从uintptr到Pointer的唯一有效转换。

（3）使用算术将Pointer转换为uintptr并转回Pointer

如果p指向已分配的对象，则可以通过转换为uintptr，添加偏移量以及转换回指针来推进对象，如：

p = unsafe.Pointer(uintptr(p) + offset)

此模式最常见的用途是访问结构中的字段或数组的元素：

//等效于 f := unsafe.Pointer(&s.f)
f := unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + unsafe.Offsetof(s.f))
//等效于 e := unsafe.Pointer(&x[i])
e := unsafe.Pointer(uintptr(unsafe.Pointer(&x[0])) + i*unsafe.Sizeof(x[0]))

以这种方式添加和减去指针的偏移量都是有效的。

在所有情况下，结果必须继续指向原始分配的对象，否则：

var a = "hello"
b := &a
fmt.Println(*(*string)(unsafe.Pointer(^^uintptr(unsafe.Pointer(b)))),":",unsafe.Pointer(^uintptr(unsafe.Pointer(b))))
fmt.Println(*(*string)(unsafe.Pointer(^uintptr(unsafe.Pointer(b)))))
`输出：`
hello : 0xffffff3ffffefe1f
unexpected fault address 0xffffff3ffffefe1f
fatal error: fault
[signal SIGSEGV: segmentation violation code=0x1 addr=0xffffff3ffffefe1f pc=0x1091f4b]
// 可以看出第一条可以正常打印，第二条打印语句失败。

与C不同，将指针推进到原始分配的末尾是无效的，如：

var s typeName
end = unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + unsafe.Sizeof(s))
fmt.Println("end:",*(*string)(end))
`输出：`
panic: runtime error: invalid memory address or nil pointer dereference

在分配空间之外的端点是无效的，如：

n := 2
b := make([]byte, n)
fmt.Println(len(b))
end := unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(n))
fmt.Println("end:", (*reflect.SliceHeader)(end).Len)
`输出：`
2
end: 734649689214812160

注意?： unsafe.Pointer和uintptr相互转换必须出现在一个表达式中，它们之间只有介入算术，在转换回Pointer之前，uintptr不能存储在变量中，如：

u := uintptr(p)
p = unsafe.Pointer(u + offset)

请注意，指针必须指向已分配的对象，因此它不会是nil，转换nil指针无效，如：

u := unsafe.Pointer(nil)
p := unsafe.Pointer(uintptr(u) + offset)

（4）在调用syscall.Syscall时将Pointer转换为uintptr

syscall中的Syscall函数将它们的uintptr参数直接传递给操作系统，然后操作系统可能会根据调用的详细信息将其中的一些重新解释为指针。

也就是说，系统调用实现隐式地将某些参数从uintptr转换回指针。

如果必须将指针参数转换为uintptr以用作参数，则该转换必须出现在调用表达式本身中：

syscall.Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(n))
//实现在：go1.12beta2/src/syscall/asm_linux_amd64.s

编译器将被引用的已经分配的对象保留，并且在调用完成之前不会移动，来处理在汇编中实现的函数调用的参数列表中将Pointer转换为uintptr的参数，即使仅从对象的类型中看起来在调用期间不再需要该对象。

要使编译器识别此模式，转换必须出现在参数列表中：

例如：

u := uintptr(unsafe.Pointer(p))
syscall.Syscall(SYS_READ, uintptr(fd), u, uintptr(n))
//在系统调用期间uintptr隐式转换回Pointer之前，uintptr不能存储在变量中

（5）将reflect.Value.Pointer或reflect.Value.UnsafeAddr的结果从uintptr转换为Pointer

reflect的名为Pointer和UnsafeAddr的方法返回类型是uintptr而不是unsafe.Pointer，是为了防止调用者在没有先导入unsafe包的情况下将结果更改为任意类型。

但是，这意味着结果很脆弱，并且必须像下面所示在调用后在同一表达式中立即转换为Pointer：

p := (*int)(unsafe.Pointer(reflect.ValueOf(new(int)).Pointer()))

与上述情况一样，在转换之前存储结果无效：

u := reflect.ValueOf(new(int)).Pointer()
p := (*int)(unsafe.Pointer(u))

（6）reflect.SliceHeader或reflect.StringHeader Data字段与Pointer相互转换

与（5）一样，反射数据结构SliceHeader和StringHeader将字段Data声明为uintptr，防止调用者在没有先导入unsafe包的情况下将结果更改为任意类型。

但是，这意味着SliceHeader和StringHeader仅在解释实际切片或字符串值的内容时有效。

var s = "hello"
var a = "你好"
hdr := (*reflect.StringHeader)(unsafe.Pointer(&s))
hdr.Data = (*reflect.StringHeader)(unsafe.Pointer(&a)).Data
hdr.Len = len(a) //长度必须不小于a，否则会截断
fmt.Printf("s:%v,len(s):%v\na:%v,len(a):%v\t", s, len(s), a, len(a))
`输出：`
s:你好,len(s):6
a:你好,len(a):6
//该种方法可以直接绕过类型系统，直接修改底层 Data 地址，
//避免在长字符串赋值时大量的内存拷贝，毕竟 Data 才8个字节。

上面例子中，hdr.Data实际上是一种引用字符串头中的底层指针uintprt。

通常，reflect.SliceHeader和reflect.StringHeader只能用作*reflect.SliceHeader和*reflect.StringHeader指向实际的切片或字符串，而不是普通的结构，程序不应声明或分配这些结构类型的变量。

例如：

var a = "你好"
var hdr reflect.StringHeader
hdr.Data = (*reflect.StringHeader)(unsafe.Pointer(&a)).Data
hdr.Len = len(a)
s:= *(*string)(unsafe.Pointer(&hdr)) //&a可能已经丢失

tips：类型声明和类型别名区别

package main
import "fmt"
type A = int
type I int
func main() {
 v := 100
 var a A = v // 不报错
 var i I = v // 编译报错，`cannot use v (type int) as type I in assignment`
 //但是可以强转，temp:=(I)(v) 
 //或 I--->int，
 //var v I
 //temp:=(int)(v)
 fmt.Println(a,i)
}