指针类型转换

在 Go 语言中，处于平安思考，是不容许两个指针类型进行转换的，比方 int 不能转为 float64。

func main() {
    i := 5
    ip := &i
    var fp *float64 = (*float64)(ip)
}

运行后果：

cannot convert ip (type * int) to type * float64

发现报错了，并不能进行强制转型。
如果你非要~，那么 Go 提供了 unsafe 包，应用包里的 Pointer 来进行转换！

unsafe.Pointer

unsafe.Pointer 是一种非凡意义的指针，能够示意任意类型的地址。应用它能够进行两个指针类型的转换。

func main() {
   i:= 5
   ip := &i
   var fp *float64 = (*float64)(unsafe.Pointer(ip))
   *fp = *fp * 6
   fmt.Println(i)
}

示例中咱们通过 unsafe.Pointer 能够在不同指针类型之间做任何转换。咱们看下 unsafe.Pointer 的源码定义：

// ArbitraryType is here for the purposes of documentation
// only and is not actually part of the unsafe package. 
// It represents the type of an arbitrary Go expression.
type ArbitraryType int
type Pointer *ArbitraryType

• ArbitraryType 能够示意任何类型，ArbitraryType 咱们无需关注太多，晓得它能够示意任何类型即可
• unsafe.Pointer 是 *ArbitraryType，表明 unsafe.Pointer 是任何类型的指针，是一个通用型的指针，能够示意任何内存地址。

uintptr 指针类型

uintptr 也是一种指针类型，也能够示意任何类型，和 unsafe.Pointer 的区别是，uintptr 能够进行运算 。通过 uintptr 能够对指针偏移进行计算，来达到拜访特定的内存，对特定内存进行读写的目标。
示例：

func main() {p := new(person)
   //Name 是 person 的第一个字段不必偏移，即可通过指针批改
   pName := (*string)(unsafe.Pointer(p))
   *pName = "微客鸟窝"
   //Age 并不是 person 的第一个字段，所以须要进行偏移，这样能力正确定位到 Age 字段这块内存，才能够正确的批改
   pAge := (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(p))+unsafe.Offsetof(p.Age)))
   *pAge = 20
   fmt.Println(*p)
}
type person struct {
   Name string
   Age int
}
// 运行后果：{微客鸟窝 20}

解析：

1. 先应用 new 函数申明一个 *person 类型的指针变量 p。
2. 而后把 person 类型的指针变量 p 通过 unsafe.Pointer，转换为 string 类型的指针变量 pName。
3. 因为 person 这个构造体的第一个字段就是 string 类型的 Name，所以 pName 这个指针就指向 Name 字段（偏移为 0），对 pName 进行批改其实就是批改字段 Name 的值。
4. 因为 Age 字段不是 person 的第一个字段，要批改它必须要进行指针偏移运算。所以须要先把指针变量 p 通过 unsafe.Pointer 转换为 uintptr，这样能力进行地址运算。具体偏移多少？能够通过函数 unsafe.Offsetof 计算出来，该函数返回的是一个 uintptr 类型的偏移量，有了这个偏移量就能够通过 + 号运算符取得正确的 Age 字段的内存地址了，也就是通过 unsafe.Pointer 转换后的 *int 类型的指针变量 pAge。
5. 如果要进行指针运算，要先通过 unsafe.Pointer 转换为 uintptr 类型的指针。指针运算结束后，还要通过 unsafe.Pointer 转换为实在的指针类型，这样能够对这块内存进行赋值或取值操作。
6. 有了指向字段 Age 的指针变量 pAge，就能够对其进行赋值操作，批改字段 Age 的值了。

7. 示例仅仅为了演示 uintptr 的指针运算，失常编码构造体赋值没有这么简单：

   p :=new(person)
   p.Name = "微客鸟窝"
   p.Age = 20
   fmt.Println(*p)
   } 

指针转换规则

三种指针类型：*T、unsafe.Pointer、unitptr

*T ←互转→ unsafe.Pointer ←互转→ unitptr

• unsafe.Pointer 次要用于指针类型的转换，是各个指针类型转换的桥梁。
• uintptr 次要用于指针运算，尤其是通过偏移量定位不同的内存。

unsafe.Sizeof

Sizeof 函数能够返回一个类型所占用的内存大小，这个大小只与类型无关，和类型对应的变量存储的数据大小无关，比方 bool 型占用一个字节、int8 也占用一个字节。
通过 Sizeof 函数能够查看任何类型占用的内存大小，示例：

package main

import (
    "fmt"
    "unsafe"
)

func main() {fmt.Println(unsafe.Sizeof(true)) //1
    fmt.Println(unsafe.Sizeof(int8(0 //1
    fmt.Println(unsafe.Sizeof(int16(10))) //2
    fmt.Println(unsafe.Sizeof(int32(10000000))) //2
    fmt.Println(unsafe.Sizeof(int64(10000000000000))) //1
    fmt.Println(unsafe.Sizeof(int(10000000000000000)))
    fmt.Println(unsafe.Sizeof(string("微客鸟窝")))
    fmt.Println(unsafe.Sizeof([]string{"有码无尘","无尘"}))
}

• 对于整型，占用的字节数意味着这个类型存储数字范畴的大小，比方 int8 占用一个字节，也就是 8bit，所以它能够存储的大小范畴是 -128~~127，也就是 −2^(n-1) 到 2^(n-1)−1。其中 n 示意 bit，int8 示意 8bit，int16 示意 16bit，以此类推。
• 对于和平台无关的 int 类型，要看平台是 32 位还是 64 位，会取最大的。
• 一个 struct 构造体的内存占用大小，等于它蕴含的字段类型内存占用大小之和。