拷貝的是數(shù)據(jù)本身，創(chuàng)造一個樣的新對象，新創(chuàng)建的對象與原對象不共享內(nèi)存，新創(chuàng)建的對象在內(nèi)存中開辟一個新的內(nèi)存地址，新對象值修改時不會影響原對象值。既然內(nèi)存地址不同，釋放內(nèi)存地址時，可分別釋放。

值類型的數(shù)據(jù)，默認(rèn)全部都是深復(fù)制，Array、Int、String、Struct、Float，Bool。

2、淺拷貝（Shallow Copy）

拷貝的是數(shù)據(jù)地址，只復(fù)制指向的對象的指針，此時新對象和老對象指向的內(nèi)存地址是一樣的，新對象值修改時老對象也會變化。釋放內(nèi)存地址時，同時釋放內(nèi)存地址。

引用類型的數(shù)據(jù)，默認(rèn)全部都是淺復(fù)制，Slice，Map。

二、本質(zhì)區(qū)別

是否真正獲取（復(fù)制）對象實(shí)體，而不是引用。

三、示例

淺拷貝

等號賦值

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}

關(guān)于copy函數(shù)：

1.copy只能用于切片，不能用于 map 等任何其他類型。
2.copy返回結(jié)果為一個 int 型值，表示 copy 從原切片src復(fù)制到目的切片的長度。

使用注意事項(xiàng)：

切片 dst 需要先初始化長度

在使用copy將 src 完全復(fù)制到 dst 時，需要初始化目的切片dst的長度。

1.如果 dst 長度小于 src 的長度，則拷貝src中的部分內(nèi)容；
2.如果大于，則全部拷貝過來，其余的空間填充該類型的默認(rèn)值；
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 多維切片中的每一個切片類型的元素，那么就需要將每個切片元素進(jìn)行初始化并拷貝。注意是兩步：

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和等號復(fù)制的區(qū)別

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

深拷貝

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

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

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

基于序列化和反序列化來實(shí)現(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)
}