golang中的指標
1. 變數、地址與指標
在程式中，變數是一種占位符，用于指代記憶體中某一段的值，每一個變數都對應一個記憶體地址，在該地址上存盤著該變數的內容，
我們常說的“指標”也是一種特殊的變數，特殊之處在于，指標變數存盤的是記憶體中的某處地址，也就是說可以根據指標變數的內容到對應的變數單元，由此我們將這種存盤記憶體地址的變數稱作“指標”，
2. go語言中的符號*與&
在go中，符號&用于取地址，例如：
package main
import "fmt"
func main() {
var a int = 10
fmt.Printf("a的存盤地址為: %p\n", &a)
//a的存盤地址為: 0xc0000121c0
}
輸出為：
a的存盤地址為: 0xc0000121c0
符號*有兩種作用：
(1)宣告變數時放在型別前，表明變數為指標變數，如
var i *int //宣告i為指向整型的指標變數
(2)放在指標變數前，用于取出該指標所指向的值，如
func main() {
var a int = 8
var ptr *int = &a
fmt.Printf("ptr指向的地址為: %v\n", ptr)
fmt.Printf("ptr指向的地址中存盤的內容為: %v\n", *ptr) //此處*用于從地址中取值
}
輸出為：
ptr指向的地址為: 0xc0000121c0
ptr指向的地址所存盤的內容為: 8
3. 指標的指標
文章開頭提到，指標自身也是一種特殊的變數，意味著指標也會有自己的存盤地址，故若一個指標變數指向另一個指標的地址，我們便稱其為指向指標的指標變數，采用如下方式宣告：
var pptr **int
宣告指標的指標需要兩個*號，類似的，我們還可以用三個*號來宣告指向指向指標的指標的指標變數....當然，這在實際使用中絕少用到，事實上，指標的指標的實際使用頻率也不會很高，這里提及此概念，主要是為了理解指標也是一種變數，
給出如下一段指標的指標使用示例
func main() {
var a int = 1
var ptr *int = &a
var ptrToPtr **int = &ptr
//注意：此處不能寫&&a，因為&a的結果沒有存入指定的變數，無法對其取地址
fmt.Printf("a = %d\n", a)
fmt.Printf("指標ptr指向地址 %p\n", ptr)
fmt.Printf("指標的指標ptrToPtr指向地址 %p\n", ptrToPtr)
fmt.Printf("指標 *ptr = %d\n", *ptr)
fmt.Printf("指標的指標變數 **ptrToPtr = %d\n", **ptrToPtr)
}
輸出結果為：
a = 1
指標ptr指向地址 0xc0000a0158
指標的指標ptrToPtr指向地址 0xc0000ca018
指標 *ptr = 1
指標的指標變數 **ptrToPtr = 1
4. 指標陣列與陣列指標
（1）陣列指標
陣列指標是一個指標，指向某一個陣列，
采用如下陳述句宣告陣列指標：
var arrPtr *[size]Type
示例：
func main() {
var arrPtr *[3]int //宣告陣列指標arrPtr
var arr = [3]int{1, 2, 3}
arrPtr = &arr // 將陣列 arr的地址賦值給arrPtr
fmt.Printf("arr的記憶體地址arrPtr=%p\n", arrPtr)
}
運行可得輸出：
arr的記憶體地址arrPtr=0xc0000104e0
前文提到過，*可用于從地址取值，則可用*從arrPtr中訪問arr的元素，需要注意的是，若寫成如下形式：
*arrPtr[0]
則程式會報錯：
invalid indirect of arrPtr[0] (type int)
原因是，[]運算子優先級高于*運算子，則上述運算會計算arrPtr[0]中取出整數1，再對整數1進行*尋址，自然會報錯，解決方法是用括號（）調整運算的優先級：
(*arrPtr)[0]
但是在實際使用中，Golang允許我們省略*號，直接寫作：
arrPtr[0]
通過如下代碼進行一下測驗：
fmt.Printf("arr的首元素(*arrPtr)[0] = %d\n", (*arrPtr)[0])
fmt.Printf("arr的首元素arrPtr[0] = %d\n", arrPtr[0])
輸出可得：
arr的首元素(*arrPtr)[0] = 1
arr的首元素arrPtr[0] = 1
但需注意，允許省略*號的情況十分局限，通過陣列指標訪問陣列內元素是其中一種情況，
還有另一種情況允許省略*號，即訪問結構體指標的欄位或者方法時，例如，有如下結構體指標：
s:=&struct{}
在訪問struct下的欄位或者方法時，本應采用運算式：
(*s).variable
(*s).method()
但這里golang提供了省略*號的語法糖，上述運算式可簡略為：
s.variable
s.method()
（2）指標陣列
指標陣列是一個陣列，其中每個元素都是指標，或者說都是地址值，
采用如下陳述句宣告指標陣列：
var ptrArr [size]*Type
示例：
func main() {
a, b := 1, 2
var ptrArr []*int = []*int{&a, &b} //構建指標陣列
for i := 0; i < 2; i++ {
fmt.Printf("ptrArr[%d] = %p\n", i, ptrArr[i])
}
for i := 0; i < 2; i++ {
fmt.Printf("ptrArr[%d]指向的值*ptrArr[i] = %d\n", i, *ptrArr[i])
//用*取出第i個指標指向的值，此處的符號*不可省略
}
}
輸出可得：
ptrArr[0] = 0xc0000121c0
ptrArr[1] = 0xc0000121c8
ptrArr[0]指向的值*ptrArr[i] = 1
ptrArr[1]指向的值*ptrArr[i] = 2
5. golang采用值傳遞
值傳遞與參考傳遞的概念由來已久，每當我們接觸一門新的語言，一定要關注的便是其函式呼叫程序中傳遞的引數到底是值還是參考？話題展開之前，首先明確值傳遞與參考傳遞的概念：
值傳遞(pass by value)：
在呼叫函式時將實際引數復制一份傳遞到函式中，這樣在函式中如果對引數進行修改，將不會影響到實際引數，
參考傳遞(pass by reference):
在呼叫函式時將實際引數的地址直接傳遞到函式中，那么在函式中對引數所進行的修改，將影響到實際引數，
具體到golang語言上，官方檔案已經給出答案：
In a function call, the function value and arguments are evaluated in the user order. After they are evaluated, the parameters of the call are passed by value to the function and the called function begins execution. The return parameters of the function are passed by value back to the calling function when the function returns.
可見，golang的函式呼叫采用的是值傳遞，下面，用幾個代碼實體驗證一下，
實體一（函式傳遞整型變數）
func main() {
var a int = 10
fmt.Printf("執行函式之前, a=%v\n", a)
fmt.Printf("原始地址為: %p\n", &a)
tryToChange(a)
fmt.Printf("執行函式之后, a=%v\n", a)
}
func tryToChange(b int) {
fmt.Printf("函數接收到的引數地址為: %p\n", &b)
b = 20
}
得到輸出：
執行函式之前, a=10
原始地址為: 0xc0000a0158
函式接收到的引數地址為: 0xc0000a0188
執行函式之后, a=10
觀察上面的輸出，可以發現：（1）傳遞給函式的值并未修改成功（2）實參a和形參b的地址并不一樣，說明函式在接收到實參a后，為形參b在區域變數的堆疊中開辟了新的空間，并拷貝a的值，因此函式內部對形參b的任何操作都不會對實參a產生影響，故而a的值沒有被修改，
實體二（函式傳遞指標）
func main() {
var a int = 10
var ptr_a *int = &a
fmt.Printf("執行函式之前, a=%v\n", a)
fmt.Printf("原始指標的存盤地址為: %p\n", &ptr_a)
fmt.Printf("原始指標指向的地址為: %p\n", ptr_a)
tryToChange(ptr)
fmt.Printf("執行函式之后, a=%v\n", a)
}
func tryToChange(ptr_b *int) {
fmt.Printf("函式接收到的指標存盤地址為: %p\n", &ptr_b)
fmt.Printf("函式接收到的指標指向的地址為: %p\n", ptr_b)
*ptr_b = 20
}
運行輸出為：
執行函式之前, a=10
原始指標的存盤地址為: 0xc000006028
原始指標指向的地址為: 0xc0000121c0
函式接收到的指標存盤地址為: 0xc000006038
函式接收到的指標指向的地址為: 0xc0000121c0
執行函式之后, a=20
觀察發現，（1）整數a的值修改成功（2）實參ptr_a和形參ptr_b的存盤地址不一致，但是作為指標變數，兩者都指向整數a的地址，這再一次印證了golang采用值傳遞的特性，與第一個實體相同，實參ptr_a在傳遞給函式后，程式會為形參ptr_b重新開辟一塊地址，并將ptr_a的值（也就是整數a的地址）拷貝給ptr_b，從而程式對形參ptr_b的取值賦值操作最終都是對整數a的操作，因此在本例中a的值可以被成功修改，
實體三（函式傳遞slice）
應該說，在有了實體一和二之后，已經可以完整說明golang值傳遞特性，但是在學習golang的程序中，往往會看到這樣的錯誤描述：“go語言中，map、slice和chan采用參考傳遞，其他型別采用值傳遞”，但這與go的檔案并不一致，不難猜測，造成這樣誤會的原因是，當我們向函式內傳入一個map或者slice，函式內的修改可以反映到實參上，實際情況如何，我們用如下代碼測驗一下：
func main() {
a := []int{0, 0, 0} //創建一個切片
fmt.Printf("原始切片地址為: %p\n", &a)
fmt.Printf("原始切片首個元素的地址為: %p\n", &a[0])
fmt.Printf("修改前切片首個元素為: %v\n", a[0])
tryToChange(a)
fmt.Printf("修改后切片首個元素為: %v\n", a[0])
}
func tryToChange(b []int) {
fmt.Printf("接收到的切片地址為: %p\n", &b)
fmt.Printf("接收到的切片首個元素的地址為: %p\n", &b[0])
b[0] = 888
}
得到輸出：
原始切片地址為: 0xc000004660
原始切片首個元素的地址為: 0xc0000104e0
修改前切片首個元素為: 0
接收到的切片地址為: 0xc0000046a0
接收到的切片首個元素的地址為: 0xc0000104e0
修改后切片首個元素為: 888
從輸出結果可以看到，（1）原始切片a的地址和傳遞到函式內的切片b地址并不一致，這反映了Golang值傳遞的特性，（2）雖然切片自身的實參形參地址不同，但是函式內外訪問的切片首位元素的地址是一樣的，這是切片元素修改能夠成功的原因，這兩個看似沖突的現象同時出現，是因為切片在golang中可以被理解為一種特殊的參考型別，Slice型別的定義如下：
type Slice struct {
point Point // 記憶體地址
len int
cap int
}
slice自身并不存盤切片資料，也不直接指向底層資料，而是通過其point欄位指向底層的資料（實際上是陣列），因此，在切片引數傳遞到函式中時，代碼為形參b開辟新的空間，并拷貝了實參a的內容向b賦值，這導致了實參形參的地址不一致；另一方面，實參a與形參b的內容一致，所以其point欄位都指向的是同一處記憶體空間，由此導致了在函式內修改切片元素的值能夠成功，
在golang中，能夠用make()函式創建的變數都可以理解做參考型別，即slice、map和chan型別，但需要注意參考型別并不意味著參考傳遞，在golang中只存在值傳遞，
參考文獻
https://learnku.com/articles/44096
https://learnku.com/articles/44096
https://www.flysnow.org/2018/02/24/golang-function-parameters-passed-by-value.html
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/242245.html
標籤：其他
上一篇：秋招面經總結（Java后端開發）