淺談Go切片的值修改是否會覆蓋陣列的值

2022-02-08 19:01:20

切片與陣列

陣列

陣列是具有相同唯一型別的一組以編號且長度固定的資料項序列

陣列宣告

var identifier [len]type

切片

切片（slice）是對陣列一個連續片段的參照，切片是一個參照型別，切片是一個指標。

切片是一個長度可變的陣列。

切片宣告

var identifier []type

切片初始化

var slice1 []type = arr[start:end]

切片的值修改

修改切片的值覆蓋陣列的值

程式碼

package main

import "fmt"

func main() {
  arr := [5]int{1,2,3,4,5}
  fmt.Printf("slice modification before: array=%v len=%d cap=%dn", arr, len(arr), cap(arr))
  
  s := arr[0:3]
  fmt.Printf("len=%d cap=%d ptr=%p slice=%vn", len(s), cap(s), s, s)
  s = append(s, 6,10) 
  
  fmt.Printf("len=%d cap=%d ptr=%p slice=%vn", len(s), cap(s), s, s)
  fmt.Printf("slice modification: array=%v len=%d cap=%dn", arr, len(arr), cap(arr))
}

結果

slice modification before: array=[1 2 3 4 5] len=5 cap=5
len=3 cap=5 ptr=0xc00000c300 slice=[1 2 3]
len=5 cap=5 ptr=0xc00000c300 slice=[1 2 3 6 10]
slice modification: array=[1 2 3 6 10] len=5 cap=5

由於未超出底層陣列的容量，地址不變，陣列還是原來的陣列，所以修改切片會覆蓋陣列的值。

修改切片不覆蓋陣列的值

程式碼

package main

import "fmt"

func main() {
  arr := [5]int{1,2,3,4,5}
  fmt.Printf("slice modification before: array=%v len=%d cap=%dn", arr, len(arr), cap(arr))
  
  s := arr[0:3]
  fmt.Printf("len=%d cap=%d ptr=%p slice=%vn", len(s), cap(s), s, s)
  s = append(s, 6,10,11) 
  
  fmt.Printf("len=%d cap=%d ptr=%p slice=%vn", len(s), cap(s), s, s)
  fmt.Printf("slice modification: array=%v len=%d cap=%dn", arr, len(arr), cap(arr))
}

結果

slice modification before: array=[1 2 3 4 5] len=5 cap=5
len=3 cap=5 ptr=0xc00000c300 slice=[1 2 3]
len=6 cap=10 ptr=0xc0000141e0 slice=[1 2 3 6 10 11]
slice modification: array=[1 2 3 4 5] len=5 cap=5

超出底層陣列的容量，地址變了，會分配一個新的陣列，返回的切片指向這個新陣列，舊的陣列的值未被修改。

切片的擴容機制

切片小數1024

程式碼

package main

import "fmt"

func main() {
  arr := [5]int{1,2,3,4,5}
  
  s := arr[0:3]
  fmt.Printf("len=%d cap=%d ptr=%p slice=%vn", len(s), cap(s), s, s)
  s = append(s, 6,10,11) 
  
  fmt.Printf("len=%d cap=%d ptr=%p slice=%vn", len(s), cap(s), s, s)
}

結果

before: len=3 cap=5 ptr=0xc00000c300 slice=[1 2 3]
after: len=6 cap=10 ptr=0xc0000141e0 slice=[1 2 3 6 10 11]

該切片的容量為源切片容量的2倍

切片不小於1024

程式碼

package main

import "fmt"

func main() {
  arr := [1024]int{1,2,3,...,1024}
  s := arr[0:] 
  fmt.Printf("before: len=%d cap=%d ptr=%p slice=%vn", len(s), cap(s), s, s)

  s = append(s, 1025)
  fmt.Printf("after: len=%d cap=%d ptr=%p slice=%vn", len(s), cap(s), s, s)
}

結果

before: len=1024 cap=1024 ptr=0xc000112000 slice=[1 2 3 ... 1024]
after: len=1025 cap=1280 ptr=0xc00012c000 slice=[1 2 3 ... 1024 1025]

切片容量在原來的切片的容量上增加了1/4

切片原始碼

如果切片的容量不夠會呼叫growslice這個函數進行擴容

//  go1.16.6 src/runtime/slice.go
func growslice(et *_type, old slice, cap int) slice {
    ... // code
    newcap := old.cap
    doublecap := newcap + newcap
    if cap > doublecap {
        newcap = cap
    } else {
        if old.cap < 1024 {
            newcap = doublecap
        } else {
            // Check 0 < newcap to detect overflow
            // and prevent an infinite loop.
            for 0 < newcap && newcap < cap {
                newcap += newcap / 4
            }
            // Set newcap to the requested cap when
            // the newcap calculation overflowed.
            if newcap <= 0 {
                newcap = cap
            }
        }
    }
    // 根據切片型別和容量計算要分配記憶體的大小
    var overflow bool
    var lenmem, newlenmem, capmem uintptr

    switch {
    ... // code
    }

    ... // code
    // 將舊切片的資料搬到新切片開闢的地址中
    memmove(p, old.array, lenmem)

    return slice{p, old.len, newcap}
}

切片擴容的規則

如果擴容之後，還沒有觸及原陣列的容量，則切片中的指標指向的還是原陣列，如果擴容後超過了原陣列的容量，則開闢一塊新的記憶體，把原來的值拷貝過來，這種情況絲毫不會影響到原陣列。
如果切片的容量小於 1024，則擴容時其容量大小乘以2；一旦容量大小超過 1024，則增長因子變成 1.25，即每次增加原來容量的四分之一。

到此這篇關於淺談Go切片的值修改是否會覆蓋陣列的值的文章就介紹到這了,更多相關Go切片覆蓋陣列的值內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！