Go語言Slice作為函式引數詳解

C天外天S 發表於 2021-07-01
Go

Go語言Slice作為函式引數詳解

前言

首先要明確Go語言中實質只有值傳遞,引用傳遞和指標傳遞是相對於引數型別來說。

個人認為上訴的結論不對,把引用型別看做對指標的封裝,一般封裝為結構體,結構體是值型別,所以感覺都是值傳遞。不然我感覺其它語言實質不也都是值傳遞?不過我剛學Go,可能還沒完全弄懂,這個有問題可以互相討論下。

Go語言中的值型別:int、float、bool、array、sturct等,宣告一個值型別變數時,編譯器會在棧中分配一個空間,空間裡儲存的就是該變數的值。

Go語言中的引用型別:slice,map,channel,interface,func,string等,宣告一個引用型別的變數,編譯器會把例項的記憶體分配在堆上。

string和其他語言一樣,是引用型別,string的底層實現struct String { byte* str; intgo len; }; 但是因為string不允許修改,每次操作string只能生成新的物件,所以在看起來使用時像值型別。

其實引用型別可以看作對指標的封裝。

Slice切片在Go語言中實質是一種結構體型別,原始碼中定義如下:

原始碼位置:src/runtime/slice.go

type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}

從定義中我們可以知道slice是一種值型別,array是底層陣列指標,它指向底層分配的陣列;len是底層陣列的元素個數;cap是底層陣列的容量,超過容量會擴容。

問題與解析

典型問題

有了上面知識的鋪墊,下面我們來看下把slice作為函式引數傳遞的典型問題:

package main

import "fmt"

func main() {
	tmp := make([]int, 0)
    fmt.Printf("%p\n", &tmp)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
	change(tmp)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
}

func change(tmp []int) {
    fmt.Printf("%p\n", &tmp)
	tmp = append(tmp, 6)
    fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
}
//執行結果
//0xc000004078
//[] 0 0 0x59cde0
//0xc0000040c0
//[6] 1 1 0xc000014098
//[] 0 0 0x59cde0

這是一個典型問題,你所有疑問的基本這種型別的問題。

疑問點:slice不是引用型別嗎?把它做引數傳遞時實參應該同步修改啊,為什麼main函式中的tmp沒變?

解析:

從之前講的知識中我們已經知道slice實質是一個結構體,其作為引數傳遞時形參實質複製了實參整個結構體的內容,其實就是值傳遞。

形參分配有一份記憶體空間,存放和實參相同的內容,從執行結果可以看出形參的記憶體地址和實參是不同的。

因為形參中底層陣列指標和實參相同,所以當做修改操作時會同步修改到實參中,但是當使用append函式新增元素時,append函式返回的slice會覆蓋修改到形參的記憶體空間中,和實參無關,所以在main函式中實參不變。可以在上面程式碼中看到函式中形參已變但實參未變。

有同學看到上面解析之後可能還會有一些疑問,比如:

  1. append函式有擴容機制,當函式內使用append未擴容時,是不是就可以同步增加元素到實參中?
  2. 為什麼傳指標就可以和實參完全同步,指標不也和引用類似嗎?

函式中使用append時,如果擴容,其中形參記憶體空間中底層陣列的地址會被覆蓋修改為新的擴容後的底層陣列地址,而實參無變化。上面的程式碼就是如此。

其它疑問1

package main

import "fmt"

func main() {
	tmp := make([]int, 0, 5)
	tmp = append(tmp, 1, 2, 3)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
	change(tmp)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
}

func change(tmp []int) {
	tmp = append(tmp, 4)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
}
//[1 2 3] 3 5 0xc00000c300
//[1 2 3 4] 4 5 0xc00000c300
//[1 2 3] 3 5 0xc00000c300

疑問點:從程式碼中可以看出函式中使用append時是沒有擴容的,因為形參中底層陣列地址和實參是一致的,那為什麼實參中沒有增加元素?

解析:

其實實參中tmp[3]已經變為4,但是實參和形參記憶體空間中len和cap是獨立的,形參中len修改為了4但實參中len仍然為3,所以實參中未增加元素。

關於tmp[3]已經變為4可以從如下程式碼中反映出來:

package main

import "fmt"

func main() {
	tmp := make([]int, 0, 5)
	tmp = append(tmp, 1, 2, 3, 4, 5)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
	change(tmp[:3])
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
}

func change(tmp []int) {
	tmp = append(tmp, 6)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
}
//[1 2 3 4 5] 5 5 0xc00000c300
//[1 2 3 6] 4 5 0xc00000c300
//[1 2 3 6 5] 5 5 0xc00000c300

可以看出實參中4已經變為6

或者從如下程式碼中更為直接的看出:

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	tmp := make([]int, 0, 5)
	tmp = append(tmp, 1, 2, 3)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
	change(tmp)
	p := unsafe.Pointer(&tmp[2])
	q := uintptr(p) + 8
	t := (*int)(unsafe.Pointer(q))
	fmt.Println(*t)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
}

func change(tmp []int) {
	tmp = append(tmp, 4)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
}
//[1 2 3] 3 5 0xc00000c300
//[1 2 3 4] 4 5 0xc00000c300
//4
//[1 2 3] 3 5 0xc00000c300

用實參tmp[2]的地址往後移一個元素地址長度,得到tmp[3]的地址輸出,可以看到變為了3。

其它疑問2

package main

import "fmt"

func main() {
	tmp := make([]int, 0, 5)
	tmp = append(tmp, 1, 2, 3)
	fmt.Printf("%p\n", &tmp)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
	change(&tmp)
	fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)
}

func change(tmp *[]int) {
	*tmp = append(*tmp, 4)
	fmt.Printf("%p\n", tmp)
	fmt.Printf("%v %d %d %p\n", *tmp, len(*tmp), cap(*tmp), *tmp)
}
//0xc000004078
//[] 0 0 0xffdde0
//0xc000004078
//[1] 1 1 0xc000014098
//[1] 1 1 0xc000014098

疑問點:為什麼指標可以同步修改到實參,*tmp = append(*tmp, 4)這不也是覆蓋修改到形參嗎?

解析:

首先明確傳指標時傳的是slice的地址,形參是地址而非一份和實參相同內容的記憶體空間,這點從程式碼中列印的0xc000004078地址可以看出。所以*tmp = append(*tmp, 4)這段程式碼覆蓋修改的是0xc000004078這個地址指向的slice,即主函式中的tmp切片,這點從程式碼中主函式中切片tmp的底層陣列地址從0xffdde0變為0xc000014098可以看出。

結論

當傳指標時,對函式中slice的任何修改其實都是對主函式中slice的修改;當傳引用,即slice本身時,對函式中slice使用append時的修改實際是對形參新分配記憶體空間的修改而實參不變,但當直接修改slice中值時能同步修改到實參中。

參考連結

go中值傳遞、引用傳遞、指標傳遞的區別 - .追風逐月 - 部落格園

GO語言slice詳解(結合原始碼) - 就是那片海 - 部落格園 (cnblogs.com)

Go語言中slice作為引數傳遞時遇到的一些“坑” - ExplorerMan - 部落格園 (cnblogs.com)