Golang學習 - unsafe 包

------------------------------------------------------------

指針類型：

*類型：普通指針，用於傳遞對象地址，不能進行指針運算。

unsafe.Pointer：通用指針類型，用於轉換不一樣類型的指針，不能進行指針運算。

uintptr：用於指針運算，GC 不把 uintptr 當指針，uintptr 沒法持有對象。uintptr 類型的目標會被回收。

　　unsafe.Pointer 能夠和 普通指針 進行相互轉換。
　　unsafe.Pointer 能夠和 uintptr 進行相互轉換。

　　也就是說 unsafe.Pointer 是橋樑，能夠讓任意類型的指針實現相互轉換，也能夠將任意類型的指針轉換爲 uintptr 進行指針運算。

------------------------------

// 示例：經過指針修改結構體字段
package main

import (
	"fmt"
	"unsafe"
)

func main() {
	s := struct {
		a byte
		b byte
		c byte
		d int64
	}{0, 0, 0, 0}

	// 將結構體指針轉換爲通用指針
	p := unsafe.Pointer(&s)
	// 保存結構體的地址備用（偏移量爲 0）
	up0 := uintptr(p)
	// 將通用指針轉換爲 byte 型指針
	pb := (*byte)(p)
	// 給轉換後的指針賦值
	*pb = 10
	// 結構體內容跟着改變
	fmt.Println(s)

	// 偏移到第 2 個字段
	up := up0 + unsafe.Offsetof(s.b)
	// 將偏移後的地址轉換爲通用指針
	p = unsafe.Pointer(up)
	// 將通用指針轉換爲 byte 型指針
	pb = (*byte)(p)
	// 給轉換後的指針賦值
	*pb = 20
	// 結構體內容跟着改變
	fmt.Println(s)

	// 偏移到第 3 個字段
	up = up0 + unsafe.Offsetof(s.c)
	// 將偏移後的地址轉換爲通用指針
	p = unsafe.Pointer(up)
	// 將通用指針轉換爲 byte 型指針
	pb = (*byte)(p)
	// 給轉換後的指針賦值
	*pb = 30
	// 結構體內容跟着改變
	fmt.Println(s)

	// 偏移到第 4 個字段
	up = up0 + unsafe.Offsetof(s.d)
	// 將偏移後的地址轉換爲通用指針
	p = unsafe.Pointer(up)
	// 將通用指針轉換爲 int64 型指針
	pi := (*int64)(p)
	// 給轉換後的指針賦值
	*pi = 40
	// 結構體內容跟着改變
	fmt.Println(s)
}

------------------------------

　　結構體成員的內存分配是連續的，第一個成員的地址就是結構體的地址，相對於結構體的偏移量爲 0。其它成員均可以經過偏移量來計算其地址。

　　每種類型都有它的大小和對齊值，能夠經過 unsafe.Sizeof 獲取其大小，經過 unsafe.Alignof 獲取其對齊值，經過 unsafe.Offsetof 獲取其偏移量。不過 unsafe.Alignof 獲取到的對齊值只是該類型單獨使用時的對齊值，不是做爲結構體字段時與其它對象間的對齊值，這裏用不上，因此須要用 unsafe.Offsetof 來獲取字段的偏移量，進而肯定其內存地址。

------------------------------

// 測試：經過反覆編譯執行下面的代碼，觀察字段的對齊狀況
package main

import (
	"fmt"
	"math/rand"
	"os"
	"time"
)

var types = []string{
	"int", "int8", "int16", "int32", "int64",
	"uint", "uint8", "uint16", "uint32", "uint64",
	"byte", "rune", "uintptr", "bool", "string",
	"float32", "float64", "complex64", "complex128",
	"[]byte", "[]string", "map[string]int",
	"chan int", "func(int) int",
}

var values = []string{
	"0", "0", "0", "0", "0",
	"0", "0", "0", "0", "0",
	"0", "0", "0", "false", "\"\"",
	"0", "0", "0+0i", "0+0i",
	"[]byte{}", "[]string{}", "map[string]int{}",
	"nil", "func(int) int {return 0}",
}

const template1 = `package main

import (
	"fmt"
	"reflect"
)

var v = struct {
		a %v
		b %v
		c %v
		d %v
		e %v
}{%v, %v, %v, %v, %v}
`
const template2 = `
func init() {
	fmt.Printf("%#T\n", v)
    t := reflect.TypeOf(v)
    fmt.Printf("結構體大小：%v\n", t.Size())
    for i := 0; i < t.NumField(); i++ {
        showAlign(t, i)
    }
}

func showAlign(v reflect.Type, i int) {
    sf := v.Field(i)
    fmt.Printf("字段 %10v，大小：%2v，對齊：%2v，字段對齊：%2v，偏移：%2v\n",
        sf.Type.Kind(),
        sf.Type.Size(),
        sf.Type.Align(),
        sf.Type.FieldAlign(),
        sf.Offset,
    )
}`

func main() {
	GetTestFile()
}

func GetTestFile() {
	f, err := os.OpenFile("testAlign.go", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
	if err != nil {
		fmt.Println(err)
	}
	defer f.Close()

	t := [5]string{}
	v := [5]string{}
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < 5; i++ {
		n := rand.Intn(len(types))
		t[i] = types[n]
		v[i] = values[n]
	}

	fmt.Fprintf(f, template1,
		t[0], t[1], t[2], t[3], t[4],
		v[0], v[1], v[2], v[3], v[4],
	)
	fmt.Fprint(f, template2)
}

------------------------------

修改其它包中的結構體私有字段：

------------------------------

package main

import (
	"fmt"
	"reflect"
	"strings"
	"unsafe"
)

func main() {
	// 建立一個 strings 包中的 Reader 對象
	// 它有三個私有字段：s string、i int6四、prevRune int
	sr := strings.NewReader("abcdef")
	// 此時 sr 中的成員是沒法修改的
	fmt.Println(sr)
	// 可是咱們能夠經過 unsafe 來進行修改
	// 先將其轉換爲通用指針
	p := unsafe.Pointer(sr)
	// 獲取結構體地址
	up0 := uintptr(p)
	// 肯定要修改的字段（這裏不能用 unsafe.Offsetof 獲取偏移量，由於是私有字段）
	if sf, ok := reflect.TypeOf(*sr).FieldByName("i"); ok {
		// 偏移到指定字段的地址
		up := up0 + 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)
}

------------------------------

　　另外還有一種簡單的方法，不用考慮偏移量的問題：

------------------------------

// 定義一個和 strings 包中的 Reader 相同的本地結構體
type Reader struct {
	s        string
	i        int64
	prevRune int
}

func main() {
	// 建立一個 strings 包中的 Reader 對象
	sr := strings.NewReader("abcdef")
	// 此時 sr 中的成員是沒法修改的
	fmt.Println(sr)
	// 咱們能夠經過 unsafe 來進行修改
	// 先將其轉換爲通用指針
	p := unsafe.Pointer(sr)
	// 再轉換爲本地 Reader 結構體
	pR := (*Reader)(p)
	// 這樣就能夠自由修改 sr 中的私有成員了
	(*pR).i = 3 // 修改索引
	// 看看修改結果
	fmt.Println(sr)
	// 看看讀出的是什麼
	b, err := sr.ReadByte()
	fmt.Printf("%c, %v\n", b, err)
}

------------------------------------------------------------