type ArbitraryType int
type Pointer *ArbitraryType
func Sizeof(x ArbitraryType) uintptr
func Offsetof(x ArbitraryType) uintptr
func Alignof(x ArbitraryType) uintptr

type ArbitraryType int

type Pointer *ArbitraryType

// 步驟：
// (1) 聲明為一個(gè)int64類型
// (2) int64 -> float32
//（3) float32 -> int32
func TestPointerTypeConvert(t *testing.T) {
   //  (1) 聲明為一個(gè)int64類型
   int64Value := int64(20)
   // int64數(shù)據(jù)打印
   fmt.Println("int64類型的值：", int64Value)
   //打?。篿nt64類型的值： 20
   fmt.Println("int64類型的指針地址：", &int64Value)
   //打印：int64類型的指針地址： 0xc000128218
   // (2) int64 -> float32
   float32Ptr := (*float32)(unsafe.Pointer(&int64Value))
   fmt.Println("float32類型的值：", *(*float32)(unsafe.Pointer(&int64Value)))
   //打?。篺loat32類型的值： 2.8e-44
   fmt.Println("float32類型的指針地址：", (*float32)(unsafe.Pointer(&int64Value)))
   //打?。篺loat32類型的指針地址： 0xc000128218
   // (3) float32 -> int32
   fmt.Println("int32類型的指針：", (*int32)(unsafe.Pointer(float32Ptr)))
   //打?。篿nt32類型的指針： 0xc000128218
   fmt.Println("int32類型的值：", *(*int32)(unsafe.Pointer(float32Ptr)))
   //打?。篿nt32類型的值： 20
}

// (1) 聲明一個(gè)數(shù)組，持有兩個(gè)元素
// (2) 輸出第1個(gè)元素指針信息
// (3) 輸出第2個(gè)元素指針信息
// (4) 通過第一個(gè)元素指針地址加上偏移量可以得到第二個(gè)元素地址
// (5) 還原第二個(gè)元素的值
func TestUintptrWithOffset(t *testing.T) {
  // (1) 聲明一個(gè)數(shù)組，持有兩個(gè)元素
  p := []int{1,2}
  // (2) 輸出第1個(gè)元素指針信息
  fmt.Println("p[0]的指針地址：",&p[0])
  // p[0]的指針地址 0xc0000a0160
  ptr0 := uintptr(unsafe.Pointer(&p[0]))
  fmt.Println(ptr0)
  // 824634376544
  // (3) 輸出第2個(gè)元素指針信息
  fmt.Println("p[1]的指針地址：",&p[1])
  // p[1]的指針地址 0xc0000a0168
  ptr1 := uintptr(unsafe.Pointer(&p[1]))
  fmt.Println(ptr1)
  // 824634376552
  // (4) 通過第一個(gè)元素指針地址加上偏移量可以得到第二個(gè)元素指針地址
  offset := uintptr(unsafe.Pointer(&p[0])) + 8 //int類型占8字節(jié)
  ptr1ByOffset := unsafe.Pointer(offset)
  fmt.Println("p[0]的指針地址 + offset偏移量可以得到p[1]的指針地址：",ptr1ByOffset)
  // p[0]的指針地址 + offset偏移量可以得到p[1]的指針地址 0xc0000a0168
  // (5) 還原第二個(gè)元素的值
  fmt.Println("通過偏移量得到的指針地址還原值：",*(*int)(ptr1ByOffset))
  // 通過偏移量得到的指針地址還原值：2
}

//? 無效：分配空間外的端點(diǎn)
func TestOverOffset(t *testing.T) {
   // 聲明字符串變量str
   str := "abc"
   // 在str的內(nèi)存偏移量基礎(chǔ)上增加了額外的一個(gè)偏移量得到一個(gè)新的內(nèi)存偏移量，該內(nèi)存地址是不存在的
   newStr := unsafe.Pointer(uintptr(unsafe.Pointer(&str)) + unsafe.Sizeof(str))
   // 這里由于不存在該內(nèi)存偏移量的對(duì)象，肯定求不到值，這里的表現(xiàn)是一直阻塞等待
   fmt.Println(*(*string)(newStr))
}

//? 無效:在轉(zhuǎn)換回指針之前，uintptr不能存儲(chǔ)在變量中
u := uintptr(p)
p = unsafe.Pointer(u + offset)
//推薦如下這種方式，不要依靠中間變量來傳遞uintptr
p = unsafe.Pointer(uintptr(p) + offset)

//? 無效:零指針的轉(zhuǎn)換
u := unsafe.Pointer(nil)
p := unsafe.Pointer(uintptr(u) + offset)

syscall.Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(n))

//? 無效:在系統(tǒng)調(diào)用期間隱式轉(zhuǎn)換回指針之前，uintptr不能存儲(chǔ)在變量中，和上面提到的問題類似
u := uintptr(unsafe.Pointer(p))
syscall.Syscall(SYS_READ, uintptr(fd), u, uintptr(n))

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

//? 無效:在轉(zhuǎn)換回指針之前，uintptr不能存儲(chǔ)在變量中，和上面提到的問題類似
u := reflect.ValueOf(new(int)).Pointer()
p := (*int)(unsafe.Pointer(u))

var s string
hdr := (*reflect.StringHeader)(unsafe.Pointer(&s)) // case 1
hdr.Data = uintptr(unsafe.Pointer(p))              // case 6 (this case)
hdr.Len = n

// ? 無效: 直接聲明的Header不會(huì)將數(shù)據(jù)作為引用。
var hdr reflect.StringHeader
hdr.Data = uintptr(unsafe.Pointer(p))
hdr.Len = n
s := *(*string)(unsafe.Pointer(&hdr)) // p可能已經(jīng)被回收

type Model struct {
   //Field...
}
func TestSizeOf(t *testing.T) {
   boolSize := false
   intSize := 1
   int8Size := int8(1)
   int16Size := int16(1)
   int32Size := int32(1)
   int64Size := int64(1)
   arrSize := make([]int, 0)
   mapSize := make(map[string]string, 0)
   structSize := &Model{}
   funcSize := func() {}
   chanSize := make(chan int, 10)
   stringSize := "abcdefg"
   fmt.Println("bool sizeOf:", unsafe.Sizeof(boolSize))
   //bool sizeOf: 1
   fmt.Println("int sizeOf:", unsafe.Sizeof(intSize))
   //int sizeOf: 8
   fmt.Println("int8 sizeOf:", unsafe.Sizeof(int8Size))
   //int8 sizeOf: 1
   fmt.Println("int16 sizeOf:", unsafe.Sizeof(int16Size))
   //int16 sizeOf: 2
   fmt.Println("int32 sizeOf:", unsafe.Sizeof(int32Size))
   //int32 sizeOf: 4
   fmt.Println("int64 sizeOf:", unsafe.Sizeof(int64Size))
   //int64 sizeOf: 8
   fmt.Println("arrSize sizeOf:", unsafe.Sizeof(arrSize))
   //arrSize sizeOf: 24
   fmt.Println("structSize sizeOf:", unsafe.Sizeof(structSize))
   //structSize sizeOf: 8
   fmt.Println("mapSize sizeOf:", unsafe.Sizeof(mapSize))
   //mapSize sizeOf: 8
   fmt.Println("funcSize sizeOf:", unsafe.Sizeof(funcSize))
   //funcSize sizeOf: 8
   fmt.Println("chanSize sizeOf:", unsafe.Sizeof(chanSize))
   //chanSize sizeOf: 8
   fmt.Println("stringSize sizeOf:", unsafe.Sizeof(stringSize))
   //stringSize sizeOf: 16
}

type BoolIntString struct {
   A bool
   B int16
   C string
}
type StringIntBool struct {
   A string
   B int16
   C bool
}
type IntStringBool struct {
   A int16
   B string
   C bool
}
type StringBoolInt struct {
   A string
   B bool
   C int16
}
func TestOffsetOf(t *testing.T) {
   bis := &BoolIntString{}
   isb := &IntStringBool{}
   sbi := &StringBoolInt{}
   sib := &StringIntBool{}
   fmt.Println(unsafe.Offsetof(bis.A)) // 0
   fmt.Println(unsafe.Offsetof(bis.B)) // 2
   fmt.Println(unsafe.Offsetof(bis.C)) // 8
   fmt.Println("")
   fmt.Println(unsafe.Offsetof(isb.A)) // 0
   fmt.Println(unsafe.Offsetof(isb.B)) // 8
   fmt.Println(unsafe.Offsetof(isb.C)) // 24
   fmt.Println("")
   fmt.Println(unsafe.Offsetof(sbi.A)) // 0
   fmt.Println(unsafe.Offsetof(sbi.B)) // 16
   fmt.Println(unsafe.Offsetof(sbi.C)) // 18
   fmt.Println("")
   fmt.Println(unsafe.Offsetof(sib.A)) // 0
   fmt.Println(unsafe.Offsetof(sib.B)) // 16
   fmt.Println(unsafe.Offsetof(sib.C)) // 18
}

type Fields struct {
   Bool    bool
   String  string
   Int     int
   Int8    int8
   Int16   int16
   Int32   int32
   Float32 float32
   Float64 float64
}
func TestAlignof(t *testing.T) {
   fields := &Fields{}
   fmt.Println(unsafe.Alignof(fields.Bool)) // 1
   fmt.Println(unsafe.Alignof(fields.String))// 8
   fmt.Println(unsafe.Alignof(fields.Int)) // 8
   fmt.Println(unsafe.Alignof(fields.Int8)) // 1
   fmt.Println(unsafe.Alignof(fields.Int16)) // 2
   fmt.Println(unsafe.Alignof(fields.Int32))  // 4
   fmt.Println(unsafe.Alignof(fields.Float32))  // 4
   fmt.Println(unsafe.Alignof(fields.Float64))  // 8
}