一、GO語言中slice的定義
slice 是一種結構體型別，在原始碼中的定義為：
src/runtime/slice.go
type slice struct {
array unsafe.Pointer
len int
cap int
}
從定義中可以看到，slice是一種值型別，里面有3個元素，array是陣列指標，它指向底層分配的陣列；len是底層陣列的元素個數；cap是底層陣列的容量，超過容量會擴容，
二、初始化操作
slice有三種初始化操作，請看下面代碼：
package main
import "fmt"
func main() {
//1、make
a := make([]int32, 0, 5)
//2、[]int32{}
b := []int32{1, 2, 3}
//3、new([]int32)
c := *new([]int32)
fmt.Println(a, b, c)
}
這幾種初始化方式，在底層實作是不一樣的，有一種了解底層實作好的方法，就是看反匯編的呼叫函式，運行下面命令即可看到代碼某一行的反匯編：
go tool compile -S plan9Test.go | grep plan9Test.go:行號
1、make初始化
make函式初始化有三個引數，第一個是型別，第二個長度，第三個容量，容量要大于等于長度，slice的make初始化呼叫的是底層的runtime.makeslice函式，
func makeslice(et *_type, len, cap int) slice {
// NOTE: The len > maxElements check here is not strictly necessary,
// but it produces a 'len out of range' error instead of a 'cap out of range' error
// when someone does make([]T, bignumber). 'cap out of range' is true too,
// but since the cap is only being supplied implicitly, saying len is clearer.
// See issue 4085.
maxElements := maxSliceCap(et.size)
if len < 0 || uintptr(len) > maxElements {
panic(errorString("makeslice: len out of range"))
}
if cap < len || uintptr(cap) > maxElements {
panic(errorString("makeslice: cap out of range"))
}
p := mallocgc(et.size*uintptr(cap), et, true)
return slice{p, len, cap}
}
主要就是呼叫mallocgc分配一塊 個數cap*型別大小 的記憶體給底層陣列，然后回傳一個slice，slice的array指標指向分配的底層陣列，
2、[]int32{} 初始化
這種初始化底層是呼叫 runtime.newobject 函式直接分配相應個數的底層陣列，
// implementation of new builtin
// compiler (both frontend and SSA backend) knows the signature
// of this function
func newobject(typ *_type) unsafe.Pointer {
return mallocgc(typ.size, typ, true)
}
3、new([]int32) 初始化
這種初始化底層也是呼叫 runtime.newobject ，new是回傳slice 的地址，所以要取地址里面內容才是真正的slice，
三、reSlice（切片操作）
所謂reSlice，是基于已有 slice 創建新的 slice 物件，以便在容量cap允許范圍內調整屬性，
data := []int32{0,1,2,3,4,5,6}
slice := data[1:4:5] // [low:high:max]
切片操作有三個引數，low、high、max，新生成的 slice 結構體三個引數，指標array指向原slice 底層陣列元素下標為low的位置， len = high - low， cap = max - low，如下圖所示：
切片操作主要要注意的就是在原slice 容量允許范圍，超出容量范圍會報panic，
四、append 操作
slice 的 append 操作是向底層陣列尾部添加資料，回傳 新的slice物件，
請看下面一段代碼：
package main
import (
"fmt"
)
func main() {
a := make([]int32, 1, 2)
b := append(a, 1)
c := append(a, 1, 2)
fmt.Printf("a的地址：%p, 第一個元素地址：%p，容量：%v\n", &a, &a[0], cap(a))
//a的地址：0xc42000a060, 第一個元素地址：0xc42001a090，容量：2
fmt.Printf("b的地址：%p, 第一個元素地址：%p，容量：%v\n", &b, &b[0], cap(b))
//b的地址：0xc42000a080, 第一個元素地址：0xc42001a090，容量：2
fmt.Printf("c的地址：%p, 第一個元素地址：%p，容量：%v\n", &c, &c[0], cap(c))
//c的地址：0xc42000a0a0, 第一個元素地址：0xc42001a0a0，容量：4
}
從上面代碼的列印結果中可以看出：a 是一個底層陣列有一個元素，容量為2的slice；append 1個元素后，沒有超出容量，產生了一個新的slice b，a 和 b 底層陣列首元素相同地址，說明a,b共用底層陣列；append 2個元素，超出了容量，產生一個新的slice c，c的底層陣列地址變了，容量也翻倍了，
那么得出結論，append操作的運行程序：
1、如果添加資料后沒有超過原始容量，新的slice物件 和原始slice共用底層陣列，len 資料會變化，cap資料不變；
2、添加資料后超過了容量那就會擴容，重新分配一個新的底層陣列，然后拷貝底層陣列資料過去，那么append后產生的新slice物件和原始的slice就沒有任何關系了，
擴容機制
看匯編代碼可以知道，擴容呼叫的是底層函式 runtime.growslice，
這個函式是這樣定義的：
func growslice(et *_type, old slice, cap int) slice {}
這個函式傳入三個引數：slice的原始型別，原始slice，期望的最小容量；回傳一個新的slice，新slice 至少是擁有期望的最小容量，元素從原slice copy過來，
擴容規則主要是下面這段代碼：
newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
newcap = cap
} else {
if old.len < 1024 {
newcap = doublecap
} else {
for newcap < cap {
newcap += newcap / 4
}
}
}
擴容規則就是兩點：
- 如果期望的最小容量大于原始的兩倍容量時，那么新的容量就是等于期望的最小容量；
- 不滿足第一種情況，那么判斷原slice的底層陣列元素長度是不是小于1024，小于1024，新容量是原來的兩倍；大于等于1024 ，新容量是原來的1.25倍，
上面是擴容的基本規則判斷，實際上擴容還要考慮到記憶體對齊情況：
var lenmem, newlenmem, capmem uintptr
const ptrSize = unsafe.Sizeof((*byte)(nil))
switch et.size {
case 1:
lenmem = uintptr(old.len)
newlenmem = uintptr(cap)
capmem = roundupsize(uintptr(newcap))
newcap = int(capmem)
case ptrSize:
lenmem = uintptr(old.len) * ptrSize
newlenmem = uintptr(cap) * ptrSize
capmem = roundupsize(uintptr(newcap) * ptrSize)
newcap = int(capmem / ptrSize)
default:
lenmem = uintptr(old.len) * et.size
newlenmem = uintptr(cap) * et.size
capmem = roundupsize(uintptr(newcap) * et.size)
newcap = int(capmem / et.size)
}
記憶體對齊之后，擴容的倍數就會 >= 2 或則 1.25 了，
為什么要記憶體對齊？
1.平臺原因(移植原因)：不是所有的硬體平臺都能訪問任意地址上的任意資料的；某些硬體平臺只能在某些地址處取某些特定型別的資料，否則拋出硬體例外，
2.性能原因：資料結構(尤其是堆疊)應該盡可能地在自然邊界上對齊，原因在于，為了訪問未對齊的記憶體，處理器需要作兩次記憶體訪問；而對齊的記憶體訪問僅需要一次訪問，
五、函式呼叫中實參和形參的相互影響
1、slice值傳遞，在呼叫函式中直接操作底層陣列
來看下面一段代碼：
package main
import (
"fmt"
)
func OpSlice(b []int32) {
fmt.Printf("len: %d, cap: %d, data:%+v \n", len(b), cap(b), b)
//len: 5, cap: 5, data:[1 2 3 4 5]
fmt.Printf("b第一個元素地址：%p\n", &b[0])
//b第一個元素地址：0xc420016120
b[0] = 100
fmt.Printf("len: %d, cap: %d, data:%+v \n", len(b), cap(b), b)
//len: 5, cap: 5, data:[100 2 3 4 5]
fmt.Printf("b第一個元素地址：%p\n", &b[0])
//b第一個元素地址：0xc420016120
}
func main() {
a := []int32{1, 2, 3, 4, 5}
fmt.Printf("len: %d, cap: %d, data:%+v \n", len(a), cap(a), a)
//len: 5, cap: 5, data:[1 2 3 4 5]
fmt.Printf("a第一個元素地址：%p\n", &a[0])
//a第一個元素地址：0xc420016120
OpSlice(a)
fmt.Printf("len: %d, cap: %d, data:%+v \n", len(a), cap(a), a)
//len: 5, cap: 5, data:[100 2 3 4 5]
fmt.Printf("a第一個元素地址：%p\n", &a[0])
//a第一個元素地址：0xc420016120
}
從這段代碼的列印中可以看到：
main函式中的slice a 是實參，值傳遞給呼叫函式時，要臨時拷貝一份給b，所以a,b 的地址是不一樣的，slice b 結構體中的三個元素都是a中的拷貝，但是元素array是指標，指標的拷貝還是指標，他們指向同一塊底層陣列，所以a,b底層陣列的第一個元素地址是一樣的，a,b共用同一塊底層陣列，在呼叫函式中，直接改變b的第一個元素內容，函式回傳后a的第一個元素也變了，相當于改變了實參，
2、slice 指標傳遞
slice 指標傳遞就沒什么說的了，在被呼叫函式中相當于操作的是實參中同一個slice，所有修改都會反映到實參，
3、slice 切片傳遞
不擴容的情況，來看下面一段代碼：
package main
import (
"fmt"
)
func OpSlice(b []int32) {
fmt.Printf("len: %d, cap: %d, data:%+v \n", len(b), cap(b), b)
//len: 3, cap: 9, data:[1 2 3]
fmt.Printf("b第一個元素地址：%p\n", &b[0])
//b第一個元素地址：0xc42007a064
b = append(b, 100)
fmt.Printf("len: %d, cap: %d, data:%+v \n", len(b), cap(b), b)
//len: 4, cap: 9, data:[1 2 3 100]
fmt.Printf("b第一個元素地址：%p\n", &b[0])
//b第一個元素地址：0xc42007a064
}
func main() {
a := []int32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
fmt.Printf("a第2個元素地址：%p\n", &a[1])
//a第2個元素地址：0xc42007a064
fmt.Printf("len: %d, cap: %d, data:%+v \n", len(a), cap(a), a)
//len: 10, cap: 10, data:[0 1 2 3 4 5 6 7 8 9]
fmt.Printf("a第一個元素地址：%p\n", &a[0])
//a第一個元素地址：0xc42007a060
OpSlice(a[1:4])
fmt.Printf("len: %d, cap: %d, data:%+v \n", len(a), cap(a), a)
//len: 10, cap: 10, data:[0 1 2 3 100 5 6 7 8 9]
fmt.Printf("a第一個元素地址：%p\n", &a[0])
//a第一個元素地址：0xc42007a060
}
前面已經講過，切片和原slice是共用底層陣列的，不擴容情況下，對切片產生的新的slice append 操作，新增加的元素會添加到底層陣列尾部，會覆寫原有的值，反映到原slice中去；
總結
無論是slice的什么操作：拷貝，append，reSlice 等等都會產生新的slice，但是他們是共用底層陣列的，不擴容情況，他們增刪改元素都會影響到原來的slice底層陣列；擴容情況下，產生的是一個“真正的”新的slice物件，和原來的完全獨立開了，底層陣列完全不會影響，
參考資料
- 深度解密Go語言之Slice.
- Go語言學習筆記.
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/40876.html
標籤：Go