前言

unsafe.Pointer其實就是類似C的void *，在golang中是用于各種指針相互轉(zhuǎn)換的橋梁。uintptr是golang的內(nèi)置類型，是能存儲指針的整型，uintptr的底層類型是int，它和unsafe.Pointer可相互轉(zhuǎn)換。uintptr和unsafe.Pointer的區(qū)別就是：unsafe.Pointer只是單純的通用指針類型，用于轉(zhuǎn)換不同類型指針，它不可以參與指針運算；而uintptr是用于指針運算的，GC 不把 uintptr 當(dāng)指針，也就是說 uintptr 無法持有對象，uintptr類型的目標(biāo)會被回收。golang的unsafe包很強(qiáng)大，基本上很少會去用它。它可以像C一樣去操作內(nèi)存，但由于golang不支持直接進(jìn)行指針運算，所以用起來稍顯麻煩。

切入正題。利用unsafe包，可操作私有變量(在golang中稱為“未導(dǎo)出變量”，變量名以小寫字母開始)，下面是具體例子。

在$GOPATH/src下建立poit包，并在poit下建立子包p，目錄結(jié)構(gòu)如下：

$GOPATH/src

----poit

--------p

------------v.go

--------main.go

以下是v.go的代碼：

package p

import (
 "fmt"
)

type V struct {
 i int32
 j int64
}

func (this V) PutI() {
 fmt.Printf("i=%d\n", this.i)
}

func (this V) PutJ() {
 fmt.Printf("j=%d\n", this.j)
}

意圖很明顯，我是想通過unsafe包來實現(xiàn)對V的成員i和j賦值，然后通過PutI()和PutJ()來打印觀察輸出結(jié)果。

以下是main.go源代碼：

package main

import (
 "poit/p"
 "unsafe"
)

func main() {
 var v *p.V = new(p.V)
 var i *int32 = (*int32)(unsafe.Pointer(v))
 *i = int32(98)
 var j *int64 = (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Sizeof(int32(0)))))
 *j = int64(763)
 v.PutI()
 v.PutJ()
}

當(dāng)然會有些限制，比如需要知道結(jié)構(gòu)體V的成員布局，要修改的成員大小以及成員的偏移量。我們的核心思想就是：結(jié)構(gòu)體的成員在內(nèi)存中的分配是一段連續(xù)的內(nèi)存，結(jié)構(gòu)體中第一個成員的地址就是這個結(jié)構(gòu)體的地址，您也可以認(rèn)為是相對于這個結(jié)構(gòu)體偏移了0。相同的，這個結(jié)構(gòu)體中的任一成員都可以相對于這個結(jié)構(gòu)體的偏移來計算出它在內(nèi)存中的絕對地址。

具體來講解下main方法的實現(xiàn)：

var v *p.V = new(p.V)

new是golang的內(nèi)置方法，用來分配一段內(nèi)存(會按類型的零值來清零)，并返回一個指針。所以v就是類型為p.V的一個指針。

var i *int32 = (*int32)(unsafe.Pointer(v))

將指針v轉(zhuǎn)成通用指針，再轉(zhuǎn)成int32指針。這里就看到了unsafe.Pointer的作用了，您不能直接將v轉(zhuǎn)成int32類型的指針，那樣將會panic。剛才說了v的地址其實就是它的第一個成員的地址，所以這個i就很顯然指向了v的成員i，通過給i賦值就相當(dāng)于給v.i賦值了，但是別忘了i只是個指針，要賦值得解引用。

*i = int32(98)

現(xiàn)在已經(jīng)成功的改變了v的私有成員i的值，好開心_

但是對于v.j來說，怎么來得到它在內(nèi)存中的地址呢？其實我們可以獲取它相對于v的偏移量(unsafe.Sizeof可以為我們做這個事)，但我上面的代碼并沒有這樣去實現(xiàn)。各位別急，一步步來。

var j *int64 = (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Sizeof(int32(0)))))

其實我們已經(jīng)知道v是有兩個成員的，包括i和j，并且在定義中，i位于j的前面，而i是int32類型，也就是說i占4個字節(jié)。所以j是相對于v偏移了4個字節(jié)。您可以用uintptr(4)或uintptr(unsafe.Sizeof(int32(0)))來做這個事。unsafe.Sizeof方法用來得到一個值應(yīng)該占用多少個字節(jié)空間。注意這里跟C的用法不一樣，C是直接傳入類型，而golang是傳入值。之所以轉(zhuǎn)成uintptr類型是因為需要做指針運算。v的地址加上j相對于v的偏移地址，也就得到了v.j在內(nèi)存中的絕對地址，別忘了j的類型是int64，所以現(xiàn)在的j就是一個指向v.j的指針，接下來給它賦值：

*j = int64(763)

好吧，現(xiàn)在貌視一切就緒了，來打印下：

v.PutI()
v.PutJ()

如果您看到了正確的輸出，那恭喜您，您做到了！

但是，別忘了上面的代碼其實是有一些問題的，您發(fā)現(xiàn)了嗎？

在p目錄下新建w.go文件，代碼如下：

package p

import (
 "fmt"
 "unsafe"
)

type W struct {
 b byte
 i int32
 j int64
}

func init() {
 var w *W = new(W)
 fmt.Printf("size=%d\n", unsafe.Sizeof(*w))
}

需要修改main.go的代碼嗎？不需要，我們只是來測試一下。w.go里定義了一個特殊方法init，它會在導(dǎo)入p包時自動執(zhí)行，別忘了我們有在main.go里導(dǎo)入p包。每個包都可定義多個init方法，它們會在包被導(dǎo)入時自動執(zhí)行(在執(zhí)行main方法前被執(zhí)行，通常用于初始化工作)，但是，最好在一個包中只定義一個init方法，否則您或許會很難預(yù)期它的行為)。我們來看下它的輸出：

size=16

等等，好像跟我們想像的不一致。來手動計算一下：b是byte類型，占1個字節(jié)；i是int32類型，占4個字節(jié)；j是int64類型，占8個字節(jié)，1+4+8=13。這是怎么回事呢？這是因為發(fā)生了對齊。在struct中，它的對齊值是它的成員中的最大對齊值。每個成員類型都有它的對齊值，可以用unsafe.Alignof方法來計算，比如unsafe.Alignof(w.b)就可以得到b在w中的對齊值。同理，我們可以計算出w.b的對齊值是1，w.i的對齊值是4，w.j的對齊值也是4。如果您認(rèn)為w.j的對齊值是8那就錯了，所以我們前面的代碼能正確執(zhí)行(試想一下，如果w.j的對齊值是8，那前面的賦值代碼就有問題了。也就是說前面的賦值中，如果v.j的對齊值是8，那么v.i跟v.j之間應(yīng)該有4個字節(jié)的填充。所以得到正確的對齊值是很重要的)。對齊值最小是1，這是因為存儲單元是以字節(jié)為單位。所以b就在w的首地址，而i的對齊值是4，它的存儲地址必須是4的倍數(shù)，因此，在b和i的中間有3個填充，同理j也需要對齊，但因為i和j之間不需要填充，所以w的Sizeof值應(yīng)該是13+3=16。如果要通過unsafe來對w的三個私有成員賦值，b的賦值同前，而i的賦值則需要跳過3個字節(jié)，也就是計算偏移量的時候多跳過3個字節(jié)，同理j的偏移可以通過簡單的數(shù)學(xué)運算就能得到。

比如也可以通過unsafe來靈活取值：

package main

import (
 "fmt"
 "unsafe"
)

func main() {
 var b []byte = []byte{'a', 'b', 'c'}
 var c *byte = b[0]
 fmt.Println(*(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(c)) + uintptr(1))))
}

關(guān)于填充，F(xiàn)astCGI協(xié)議就用到了。

總結(jié)

以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，如果有疑問大家可以留言交流，謝謝大家對腳本之家的支持。