package main
 
import (
    "fmt"
    "reflect"
    "unsafe"
)
 
func main() {
    slice1 := []int{1,2,3,4,5}
    slice2 := slice1
    fmt.Println(slice1)
    fmt.Println(slice2)
    //同時改變兩個數(shù)組
    slice1[1]=100
    fmt.Println(slice1)
    fmt.Println(slice2)
    fmt.Println("切片1指向的底層數(shù)組地址:",(*reflect.SliceHeader)(unsafe.Pointer(&slice1)))
    fmt.Println("切片2指向的底層數(shù)組地址:",(*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指向的底層數(shù)組地址: &{824634425392 5 5}
切片2指向的底層數(shù)組地址: &{824634425392 5 5}

關于copy函數(shù)：

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 函數(shù)，拷貝的是切片中的元素，所以如果切片元素的類型是引用類型，那么 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, %p\n", matA, matA[0]) // 0xc0000c0000, 0xc0000c2000
    fmt.Printf("%p, %p\n", matB, matB[0]) // 0xc0000c0050, 0xc0000c2000
}

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

1.先初始化每維切片，
2.再拷貝。
正確拷貝一個多維數(shù)組的打開方式：

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, %p\n", matA, matA[0]) // 0xc00005c050, 0xc000018560
    fmt.Printf("%p, %p\n", matB, matB[0]) // 0xc00005c0a0, 0xc0000185c0
}

切片使用copy和等號復制的區(qū)別

1.性能方面：copy復制會比等號復制慢。 2.復制方式：copy復制為值復制，改變原切片的值不會影響新切片。而等號復制為指針復制，改變原切片或新切片都會對另一個產(chǎn)生影響。

深拷貝

(淺)拷貝對于值類型的話是完全拷貝一份相同的值；而對于引用類型是拷貝其地址，也就是拷貝的對象修改引用類型的變量同樣會影響到源對象。

對于深拷貝，任何對象都會被完完整整的拷貝一份，拷貝對象與被拷貝對象不存在任何聯(lián)系，也就不會互相影響。

如果你需要拷貝的對象中沒有引用類型，那么對于Golang而言使用淺拷貝就可以了。

基于序列化和反序列化來實現(xiàn)對象的深度拷貝:

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)
}