前言

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

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

在$GOPATH/src下建立poit包，并在poit下建立子包p，目錄結構如下：

$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包來實現對V的成員i和j賦值，然后通過PutI()和PutJ()來打印觀察輸出結果。

以下是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()
}

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

具體來講解下main方法的實現：

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

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

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

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

*i = int32(98)

現在已經成功的改變了v的私有成員i的值，好開心_

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

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

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

*j = int64(763)

好吧，現在貌視一切就緒了，來打印下：

v.PutI()
v.PutJ()

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

但是，別忘了上面的代碼其實是有一些問題的，您發現了嗎？

在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，它會在導入p包時自動執行，別忘了我們有在main.go里導入p包。每個包都可定義多個init方法，它們會在包被導入時自動執行(在執行main方法前被執行，通常用于初始化工作)，但是，最好在一個包中只定義一個init方法，否則您或許會很難預期它的行為)。我們來看下它的輸出：

size=16

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

比如也可以通過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))))
}

關于填充，FastCGI協議就用到了。

總結

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