Golang中的深拷貝與淺拷貝使用

2023-04-04 06:01:00

一、概念

1、深拷貝（Deep Copy）

拷貝的是資料本身，創造一個樣的新物件，新建立的物件與原物件不共用記憶體，新建立的物件在記憶體中開闢一個新的記憶體地址，新物件值修改時不會影響原物件值。既然記憶體地址不同，釋放記憶體地址時，可分別釋放。

值型別的資料，預設全部都是深複製，Array、Int、String、Struct、Float，Bool。

2、淺拷貝（Shallow Copy）

拷貝的是資料地址，只複製指向的物件的指標，此時新物件和老物件指向的記憶體地址是一樣的，新物件值修改時老物件也會變化。釋放記憶體地址時，同時釋放記憶體地址。

參照型別的資料，預設全部都是淺複製，Slice，Map。

二、本質區別

是否真正獲取（複製）物件實體，而不是參照。

三、範例

淺拷貝

等號賦值

package main
 
import (
    "fmt"
    "reflect"
    "unsafe"
)
 
func main() {
    slice1 := []int{1,2,3,4,5}
    slice2 := slice1
    fmt.Println(slice1)
    fmt.Println(slice2)
    //同時改變兩個陣列
    slice1[1]=100
    fmt.Println(slice1)
    fmt.Println(slice2)
    fmt.Println("切片1指向的底層陣列地址:",(*reflect.SliceHeader)(unsafe.Pointer(&slice1)))
    fmt.Println("切片2指向的底層陣列地址:",(*reflect.SliceHeader)(unsafe.Pointer(&slice2)))
}

輸出資訊：

[1 2 3 4 5]
[1 2 3 4 5]
[1 100 3 4 5]
[1 100 3 4 5]
切片1指向的底層陣列地址: &{824634425392 5 5}
切片2指向的底層陣列地址: &{824634425392 5 5}

關於copy函數：

1.copy只能用於切片，不能用於 map 等任何其他型別。
2.copy返回結果為一個 int 型值，表示 copy 從原切片src複製到目的切片的長度。

使用注意事項：

切片 dst 需要先初始化長度

在使用copy將 src 完全複製到 dst 時，需要初始化目的切片dst的長度。

1.如果 dst 長度小於 src 的長度，則拷貝src中的部分內容；
2.如果大於，則全部拷貝過來，其餘的空間填充該型別的預設值；
3.如果相等，剛好不多不少 copy 過來，所以，通常dst在初始化時即指定其為src的長度。

package main
 
import "fmt"
 
func main() {    
    src := []int{1, 2, 3, 5, 6, 7, 8}
    fmt.Println("src len:", len(src), "src:", src)
    dst := make([]int, 0)
    copy(dst, src)
    fmt.Println("dst len:", len(dst), "dst:", dst)
    dst1 := make([]int, len(src)/2 )
    copy(dst1, src)
    fmt.Println("dst1 len:", len(dst1), "dst1:", dst1)
    dst2 := make([]int, len(src))
    copy(dst2, src)
    fmt.Println("dst2 len:", len(dst2), "dst2:", dst2)
    dst3 := make([]int, len(src) + 2)
    copy(dst3, src)
    fmt.Println("dst3 len:", len(dst3), "dst3:", dst3)
}

輸出

src len: 7 src: [1 2 3 5 6 7 8]
dst len: 0 dst: []
dst1 len: 3 dst1: [1 2 3]
dst2 len: 7 dst2: [1 2 3 5 6 7 8]
dst3 len: 9 dst3: [1 2 3 5 6 7 8 0 0]

源切片中元素型別為參照型別時，拷貝的是參照

由於copy 函數，拷貝的是切片中的元素，所以如果切片元素的型別是參照型別，那麼 copy 的也將是個參照。

如下面例子，matA 和 matB 地址不一樣，但 matA[0] 和 matB[0] 的地址是一樣的。

func wrongCopyMatrix() {
    matA := [][]int{
        {0, 1, 1, 0},
        {0, 1, 1, 1},
        {1, 1, 1, 0},
    }
    matB := make([][]int, len(matA))
    copy(matB, matA)
    fmt.Printf("%p, %pn", matA, matA[0]) // 0xc0000c0000, 0xc0000c2000
    fmt.Printf("%p, %pn", matB, matB[0]) // 0xc0000c0050, 0xc0000c2000
}

如果想 copy 多維切片中的每一個切片型別的元素，那麼就需要將每個切片元素進行初始化並拷貝。注意是兩步：

1.先初始化每維切片，
2.再拷貝。
正確拷貝一個多維陣列的開啟方式：

func rightCopyMatrix() {
    matA := [][]int{
        {0, 1, 1, 0},
        {0, 1, 1, 1},
        {1, 1, 1, 0},
    }
    matB := make([][]int, len(matA))
    for i := range matA {
        matB[i] = make([]int, len(matA[i])) // 注意初始化長度
        copy(matB[i], matA[i])
    }
    fmt.Printf("%p, %pn", matA, matA[0]) // 0xc00005c050, 0xc000018560
    fmt.Printf("%p, %pn", matB, matB[0]) // 0xc00005c0a0, 0xc0000185c0
}

切片使用copy和等號複製的區別

1.效能方面：copy複製會比等號複製慢。 2.複製方式：copy複製為值複製，改變原切片的值不會影響新切片。而等號複製為指標複製，改變原切片或新切片都會對另一個產生影響。

深拷貝

(淺)拷貝對於值型別的話是完全拷貝一份相同的值；而對於參照型別是拷貝其地址，也就是拷貝的物件修改參照型別的變數同樣會影響到源物件。

對於深拷貝，任何物件都會被完完整整的拷貝一份，拷貝物件與被拷貝物件不存在任何聯絡，也就不會互相影響。

如果你需要拷貝的物件中沒有參照型別，那麼對於Golang而言使用淺拷貝就可以了。

基於序列化和反序列化來實現物件的深度拷貝:

import  "encoding/gob"
 
func deepCopy(dst, src interface{}) error {
    var buf bytes.Buffer
    if err := gob.NewEncoder(&buf).Encode(src); err != nil {
        return err
    }
    return gob.NewDecoder(bytes.NewBuffer(buf.Bytes())).Decode(dst)
}