2. 程式人生 > >《快學 Go 語言》第 14 課 —— 魔術變性指標

《快學 Go 語言》第 14 課 —— 魔術變性指標

阿新 • • 發佈：2018-12-19

本節我們要學習一些 Go 語言的魔法功能，通過內建的 unsafe 包提供的功能，直接操縱指定記憶體地址的記憶體。有了 unsafe 包，我們就可以洞悉 Go 語言內建資料結構的內部細節。

unsafe.Pointer

Pointer 代表著變數的記憶體地址，可以將任意變數的地址轉換成 Pointer 型別，也可以將 Pointer 型別轉換成任意的指標型別，它是不同指標型別之間互轉的中間型別。Pointer 本身也是一個整型的值。

type Pointer int
複製程式碼

在 Go 語言裡不同型別之間的轉換是要受限的。普通的基礎變數轉換成不同的型別需要進行記憶體淺拷貝，而指標變數型別之間是禁止直接轉換的。要打破這個限制，unsafe.Pointer 就可以派上用場，它允許任意指標型別的互轉。

指標的加減運算

Pointer 雖然是整型的，但是編譯器禁止它直接進行加減運算。如果要進行運算，需要將 Pointer 型別轉換 uintptr 型別進行加減，然後再將 uintptr 轉換成 Pointer 型別。uintptr 其實也是一個整型。

type uintptr int
複製程式碼

下面讓我們就來嘗試一下剛剛學到的魔法

package main

import "fmt"
import "unsafe"

type Rect struct {
	Width int
	Height int
}

func main() {
	var r = Rect {50
 
, 50}
	// *Rect => Pointer => *int => int
	var width = *(*int)(unsafe.Pointer(&r))
	// *Rect => Pointer => uintptr => Pointer => *int => int
	var height = *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + uintptr(8)))
	fmt.Println(width, height)
}

------
50 50
複製程式碼

上面的程式碼是用 unsafe 包來讀取結構體的內容，形式上比較繁瑣，注意看程式碼中的註釋，讀者需要稍微轉一轉腦袋來理解一下上面的程式碼。接下來我們再嘗試修改結構體的值

package main

import "fmt"
import "unsafe"

type Rect struct {
	Width int
	Height int
}

func main() {
	var r = Rect {50, 50}
	// var pw *int
	var pw = (*int)(unsafe.Pointer(&r))
	// var ph *int
	var ph = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + uintptr(8)))
	*pw = 100
	*ph = 100
	fmt.Println(r.Width, r.Height)
}

--------
100 100
複製程式碼

程式碼中的 uintptr(8) 很不優雅，可以使用 unsafe 提供了 Offsetof 方法來替換它，它可以直接得到欄位在結構體內的偏移量

var ph = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + unsafe.Offsetof(r.Height))
複製程式碼

你也許會抱怨為啥指標操作這麼繁瑣，不能簡單一點麼？Go 語言的設計者故意這樣設計的，因為指標操作非常的不安全，所以它要給使用者設定障礙。

探索切片內部結構

在切片小節，我們知道了切片分為切片頭和內部陣列兩部分，下面我們使用 unsafe 包來驗證一下切片的內部資料結構，看看它和我們預期的是否一樣。

package main

import "fmt"
import "unsafe"

func main() {
	// head = {address, 10, 10}
	// body = [1,2,3,4,5,6,7,8,9,10]
	var s = []int{1,2,3,4,5,6,7,8,9,10}
	var address = (**[10]int)(unsafe.Pointer(&s))
	var len = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(8)))
	var cap = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(16)))
	fmt.Println(address, *len, *cap)
	var body = **address
	for i:=0; i< len(body); i++ {
		fmt.Printf("%d ", body[i])
	}
}

------------------
0xc42000a080 10 10
1 2 3 4 5 6 7 8 9 10
複製程式碼

輸出的結果正是我們鎖期望的，不過讀者需要仔細思考一下 address 為什麼是二級指標變數。

圖片

字串與位元組切片的高效轉換

在字串小節我們提到位元組切片和字串之間的轉換需要複製記憶體，如果字串或者位元組切片的長度較大，轉換起來會有較高的成本。下面我們通過 unsafe 包提供另一種高效的轉換方法，讓轉換前後的字串和位元組切片共享內部儲存。

字串和位元組切片的不同點在於頭部，字串的頭部 2 個 int 位元組，切片的頭部 3 個 int 位元組 

package main

import "fmt"
import "unsafe"

func main() {
	fmt.Println(bytes2str(str2bytes("hello")))
}

func str2bytes(s string) []byte {
	var strhead = *(*[2]int)(unsafe.Pointer(&s))
	var slicehead [3]int
	slicehead[0] = strhead[0]
	slicehead[1] = strhead[1]
	slicehead[2] = strhead[1]
	return *(*[]byte)(unsafe.Pointer(&slicehead))
}

func bytes2str(bs []byte) string {
	return *(*string)(unsafe.Pointer(&bs))
}

-----
hello
複製程式碼

切記通過這種形式轉換而成的位元組切片千萬不可以修改，因為它的底層位元組陣列是共享的，修改會破壞字串的只讀規則。其次使用這種形式得到的字串或者切片只可以用作臨時的區域性變數，因為被共享的位元組陣列隨時可能會被回收，原字串或者位元組切片的記憶體由於不再被引用，讓垃圾回收器解決掉了。

深入介面變數的賦值

在介面變數的小節，有一個問題還懸而未決，那就是介面變數在賦值時發生了什麼？

通過 unsafe 包，我們就可以看清裡面的細節，下面我們將一個結構體變數賦值給介面變數，看看修改結構體的記憶體會不會影響到介面變數的資料記憶體 

package main

import "fmt"
import "unsafe"

type Rect struct {
	Width int
	Height int
}

func main() {
	var r = Rect{50, 50}
	// {typeptr, dataptr}
	var s interface{} = r
	
	var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
	// var dataptr *Rect
	var sdataptr = sptrs[1]
	fmt.Println(sdataptr.Width, sdataptr.Height)
	
	// 修改原物件，看看介面指向的物件是否受到影響
	r.Width = 100
	fmt.Println(sdataptr.Width, sdataptr.Height)
}

-------
50 50
50 50
複製程式碼

從輸出中可以得出結論，將結構體變數賦值給介面變數，結構體記憶體會被複制。那如果是兩個介面變數之間的賦值呢，會不會同樣也需要複製指向的資料呢？

package main

import "fmt"
import "unsafe"

type Rect struct {
	Width int
	Height int
}

func main() {
	// {typeptr, dataptr}
	var s interface{} = Rect{50, 50}
	var r = s

	var rptrs = *(*[2]*Rect)(unsafe.Pointer(&r))
	var rdataptr = rptrs[1]
	var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
	var sdataptr = sptrs[1]

	fmt.Println(sdataptr.Width, sdataptr.Height)
	fmt.Println(rdataptr.Width, rdataptr.Height)

	// 修改原物件
	sdataptr.Width = 100
	// 再對比一下原物件和目標物件
	fmt.Println(sdataptr.Width, sdataptr.Height)
	fmt.Println(rdataptr.Width, rdataptr.Height)
}

-----------
50 50
50 50
100 50
100 50
複製程式碼

從輸出中可以發現賦值前後兩個介面變數共享了資料記憶體，沒有發生資料的複製。接下來我們再引入第 3 個問題，不同型別的介面變數賦值會不會發生複製？

package main

import "fmt"
import "unsafe"

type Areable interface {
	Area() int
}

type Rect struct {
	Width int
	Height int
}

func (r Rect) Area() int {
	return r.Width * r.Height
}

func main() {
	// {typeptr, dataptr}
	var s Areable = Rect{50, 50}
	var r interface{} = s

	var rptrs = *(*[2]*Rect)(unsafe.Pointer(&r))
	var rdataptr = rptrs[1]
	var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
	var sdataptr = sptrs[1]

	fmt.Println(sdataptr.Width, sdataptr.Height)
	fmt.Println(rdataptr.Width, rdataptr.Height)

	// 修改原物件
	sdataptr.Width = 100
	// 再對比一下原物件和目標物件
	fmt.Println(sdataptr.Width, sdataptr.Height)
	fmt.Println(rdataptr.Width, rdataptr.Height)
}

------
50 50
50 50
100 50
100 50
複製程式碼

結果是不同型別介面之間賦值指向的資料物件還是共享的。接下來我們再引入第 4 個 問題，介面型別之間在造型時是否會發生記憶體的複製。

package main

import "fmt"
import "unsafe"

type Areable interface {
	Area() int
}

type Rect struct {
	Width int
	Height int
}

func (r Rect) Area() int {
	return r.Width * r.Height
}

func main() {
	// {typeptr, dataptr}
	var s interface{} = Rect{50, 50}
	var r Areable = s.(Areable)

	var rptrs = *(*[2]*Rect)(unsafe.Pointer(&r))
	var rdataptr = rptrs[1]
	var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
	var sdataptr = sptrs[1]

	fmt.Println(sdataptr.Width, sdataptr.Height)
	fmt.Println(rdataptr.Width, rdataptr.Height)

	// 修改原物件
	sdataptr.Width = 100
	// 再對比一下原物件和目標物件
	fmt.Println(sdataptr.Width, sdataptr.Height)
	fmt.Println(rdataptr.Width, rdataptr.Height)
}

------
50 50
50 50
100 50
100 50
複製程式碼

答案是不同介面型別之間造型資料還是共享的。最後再提一個問題，將介面型別造型成結構體型別，是否會發生記憶體複製？

package main

import "fmt"
import "unsafe"

type Areable interface {
	Area() int
}

type Rect struct {
	Width int
	Height int
}

func (r Rect) Area() int {
	return r.Width * r.Height
}

func main() {
	// {typeptr, dataptr}
	var s interface{} = Rect{50, 50}
	var r Rect = s.(Rect)

	var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
	var sdataptr = sptrs[1]

	// 修改原物件
	sdataptr.Width = 100
	// 再對比一下原物件和目標物件
	fmt.Println(sdataptr.Width, sdataptr.Height)
	fmt.Println(r.Width, r.Height)
}
複製程式碼

答案是將介面造型成結構體型別，記憶體會發生複製，它們之間的資料不會共享。

從上面 5 個 問題，我們可以得出結論，介面型別和結構體型別似乎是兩個不同的世界。只有介面型別之間的賦值和轉換會共享資料，其它情況都會複製資料，其它情況包括結構體之間的賦值，結構體轉介面，介面轉結構體。不同介面變數之間的轉換本質上只是調整了介面變數內部的型別指標，資料指標並不會發生改變。

通過 unsafe 包我們還可以分析很多細節，在高階內容部分，我們將會頻繁使用這個工具。

閱讀《快學 Go 語言》更多章節，長按圖片識別二維碼關注公眾號「碼洞」

相關推薦

《快學 Go 語言》第 14 課 —— 魔術變性指標

本節我們要學習一些 Go 語言的魔法功能，通過內建的 unsafe 包提供的功能，直接操縱指定記憶體地址的記憶體。有了 unsafe 包，我們就可以洞悉 Go 語言內建資料結構的內部細節。 unsafe.Pointer Pointer 代表著變數的記憶體地址，可以將任意變數的地址轉換成 Pointer 型

快學 Go 語言第 2 課 —— 變數什麼的最討厭了

任何一門語言裡面最基礎的莫過於變量了。如果把記憶體比喻成一格一格整齊排列的儲物箱，那麼變數就是每個儲物箱的標識，我們通過變數來訪問計算機記憶體。沒有變數的程式對於人類來說是可怕的，需要我們用數字位置來定位記憶體的格子，人類極不擅長這樣的事。這就好比一歲半左右的幼兒還沒有學會很多名詞，只能用手來對物

《快學 Go 語言》第 4 課 —— 低調的陣列

陣列就是一篇連續的記憶體，幾乎所有的計算機語言都有陣列，只不過 Go 語言裡面的陣列其實並不常用，這是因為陣列是定長的靜態的，一旦定義好長度就無法更改，而且不同長度的陣列屬於不同的型別，之間不能相互轉換相互賦值，用起來多有不方便之處。 切片是動態的陣列，是可以擴充內容增加長度的陣列。當長度不變時，它用起來就

《快學 Go 語言》第 5 課 —— 靈活的切片

切片無疑是 Go 語言中最重要的資料結構，也是最有趣的資料結構，它的英文詞彙叫 slice。所有的 Go 語言開發者都津津樂道地談論切片的內部機制，它也是 Go 語言技能面試中面試官最愛問的知識點之一。初級使用者很容易濫用它，這小小的切片想要徹底的理解它是需要花費一番功夫的。在使用切片之前，我覺得很有必要將切

《快學 Go 語言》第 6 課 —— 字典

字典在數學上的詞彙是對映，將一個集合中的所有元素關聯到另一個集合中的部分或全部元素，並且只能是一一對映或者多對一對映。 陣列切片讓我們具備了可以操作一塊連續記憶體的能力，它是對同質元素的統一管理。而字典則賦予了不連續不同類的記憶體變數的關聯性，它表達的是一種因果關係，字典的 key 是因，

《快學 Go 語言》第 7 課 —— 字串

字串通常有兩種設計，一種是「字元」串，一種是「位元組」串。「字元」串中的每個字都是定長的，而「位元組」串中每個字是不定長的。Go 語言裡的字串是「位元組」串，英文字元佔用 1 個位元組，非英文字元佔多個位元組。這意味著無法通過位置來快速定位出一個完整的字元來，而必須通過遍歷的方式來逐個獲取單個字元。

《快學 Go 語言》第 8 課 —— 程式大廈是如何構建起來的

本節我們要開講 Go 語言在資料結構上最重要的概念 —— 結構體。如果說 Go 語言的基礎型別是原子，那麼結構體就是分子。分子是原子的組合，讓形式有限的基礎型別變化出豐富多樣的形態結構。結構體裡面裝的是基礎型別、切片、字典、陣列以及其它型別的結構體等等。 因為結構體的存在，Go 語言的變數

《快學 Go 語言》第 7 課 —— 誘人的烤串

字串通常有兩種設計，一種是「字元」串，一種是「位元組」串。「字元」串中的每個字都是定長的，而「位元組」串中每個字是不定長的。Go 語言裡的字串是「位元組」串，英文字元佔用 1 個位元組，非英文字元佔多個位元組。這意味著無法通過位置來快速定位出一個完整的字元來，而必須通過遍歷的方式來逐個獲取單個

《快學 Go 語言》第 9 課 —— 介面

介面是一個物件的對外能力的展現，我們使用一個物件時，往往不需要知道一個物件的內部複雜實現，通過它暴露出來的介面，就知道了這個物件具備哪些能力以及如何使用這個能力。 我們常說「佛有千面」，不同的人看到的佛並不一樣。一個複雜的複合物件常常也可以是一個多面手，它具備多種能力，在形式上實現了多種介面。「弱水三千，只

《快學 Go 語言》第 10 課 —— 錯誤與異常

Go 語言的異常處理語法絕對是獨樹一幟，在我見過的諸多高階語言中，Go 語言的錯誤處理形式就是一朵奇葩。一方面它鼓勵你使用 C 語言的形式將錯誤通過返回值來進行傳遞，另一方面它還提供了高階語言一般都有的異常丟擲和捕獲的形式，但是又不鼓勵你使用這個形式。後面我們統一將返回值形式的稱為「錯誤」，將丟擲捕獲形式的稱

《快學 Go 語言》第 11 課 —— 千軍萬馬跑協程

協程和通道是 Go 語言作為併發程式語言最為重要的特色之一，初學者可以完全將協程理解為執行緒，但是用起來比執行緒更加簡單，佔用的資源也更少。通常在一個程序裡啟動上萬個執行緒就已經不堪重負，但是 Go 語言允許你啟動百萬協程也可以輕鬆應付。如果把協程比喻成小島，那通道就是島嶼之間的交流橋樑，資料搭乘通道從一個協

《快學 Go 語言》第 12 課 —— 通道

不同的並行協程之間交流的方式有兩種，一種是通過共享變數，另一種是通過佇列。Go 語言鼓勵使用佇列的形式來交流，它單獨為協程之間的佇列資料交流定製了特殊的語法 —— 通道。 通道是協程的輸入和輸出。作為協程的輸出，通道是一個容器，它可以容納資料。作為協程的輸入，通道是一個生產者，它可以向協程提供資料。通道作為

《快學 Go 語言》第 13 課 —— 併發與安全

上一節我們提到併發程式設計不同的協程共享資料的方式除了通道之外還有就是共享變數。雖然 Go 語言官方推薦使用通道的方式來共享資料，但是通過變數來共享才是基礎，因為通道在底層也是通過共享變數的方式來實現的。通道的內部資料結構包含一個數組，對通道的讀寫就是對內部陣列的讀寫。 在併發環境下共享讀寫變數必須要使用鎖

《快學 Go 語言》第 15 課 —— 反射

反射是 Go 語言學習的一個難點，但也是非常重要的一個知識點。反射是洞悉 Go 語言型別系統設計的法寶，Go 語言的 ORM 庫離不開它，Go 語言的 json 序列化庫離不開它，Go 語言的執行時更是離不開它。筆者在學習反射功能的時候也是費了好大一番功夫才敢說自己確實搞懂了。下面請讀者跟著我的步伐來一步一步

Scala實戰高手****第14課Scala集合上的函數語言程式設計實戰及Spark原始碼鑑賞

package com.dt.spark.scala.bascis object Functional_Itearal {   def main(args: Array[String]): Unit = {        val range

Go語言第十九課 反射

package reflect import ( "testing" "strconv" "fmt" "reflect" ) type student interface { getAge

Go語言第十八課 CGO

可藉助CGO實現Go語言對C的呼叫，下面展示幾種呼叫方式。 1、直接巢狀C程式碼 C程式碼內容如下： #include <stdio.h> #include <stdlib.h> #include <string.h> char*

跟阿銘學linux   第四課   Linux磁盤管理

linux4.1 df 命令1）<df> 查看磁盤使用情況 <df -h> 按合適的單位顯示 /dev/shm 內存 -速度快 tmpfs 臨時的 重啟後會消失 <df -i> 查看inode使用情況 <df -m>

跟阿銘學linux   第五課   VIM工具

linux vim 5.1 VIM簡介 1）VIM是Vi的升級版，帶有顏色顯示 ；也分為 一般模式、編輯模式、命令行模式； <yum install -y vim-enhanced> 安裝指令包， 只安裝一個 < yum install -y

C語言-第33課 - 認清函數的真面目

程序 表達式 oid int 中心 ++ 順序執行 求職 ret 第33課 - 認清函數的真面目 一．概念 函數的由來 程序 = 數據 + 算法 C程序 = 數據 + 函數 我們下面分析一下匯編語言，匯編語言是從上到下順序執行的，匯編為了循環執行，就有了跳轉指令。通