Go切片赋值：值拷贝与深拷贝详解

Go语言的赋值机制：始终是值拷贝

Go语言在变量赋值和函数参数传递时，采用的都是严格的“值拷贝”（pass by value）机制。这意味着，无论你复制的是基本类型（如整数、布尔值）还是复合类型（如结构体、数组、切片、映射、通道、指针），Go语言都会复制其“值”。

对于基本类型，这个概念很简单：复制一个整数，你就得到了一个新的整数副本。

a := 10
b := a // b是a的一个独立副本，修改b不影响a
b = 20
fmt.Println(a, b) // 输出: 10 20

然而，当涉及到指针时，情况变得有些微妙。指针本身也是一个值，它存储的是一个内存地址。当你复制一个指针时，你复制的是这个内存地址。这意味着，两个指针变量现在都指向了内存中的同一个底层数据。

考虑以下结构体定义：

package main

import (
    "fmt"
    "container/vector" // 注意：此包在现代Go中已不常用，但此处为解释原问题而保留
)

type Move struct {
    x0, y0, x1, y1 int
}

type PegPuzzle struct {
    movesAlreadyDone *vector.Vector // 注意：这是一个指向vector.Vector的指针
}

func (p *PegPuzzle) InitPegPuzzle() {
    // 修正：vector.New() 已被移除，应使用 new(vector.Vector)
    p.movesAlreadyDone = new(vector.Vector)
}

func NewChildPegPuzzle(parent *PegPuzzle) *PegPuzzle {
    retVal := new(PegPuzzle)
    // 问题所在：这里复制的是指针的值，即内存地址
    // retVal.movesAlreadyDone 和 parent.movesAlreadyDone 指向同一个 vector.Vector 实例
    retVal.movesAlreadyDone = parent.movesAlreadyDone
    return retVal
}

func (p *PegPuzzle) doMove(move Move) {
    p.movesAlreadyDone.Push(move)
}

func (p *PegPuzzle) printPuzzleInfo() {
    fmt.Printf("-----------START----------------------\n")
    fmt.Printf("moves already done: %v\n", p.movesAlreadyDone)
    fmt.Printf("------------END-----------------------\n")
}

func main() {
    p := new(PegPuzzle)
    p.InitPegPuzzle()

    cp1 := NewChildPegPuzzle(p)
    cp1.doMove(Move{1, 1, 2, 3})
    cp1.printPuzzleInfo() // 此时 cp1.movesAlreadyDone 包含 {1,1,2,3}

    cp2 := NewChildPegPuzzle(p) // cp2 同样从原始的 p 派生
    cp2.doMove(Move{3, 2, 5, 1})
    // 预期 cp2.movesAlreadyDone 仅包含 {3,2,5,1}
    // 实际 cp2.movesAlreadyDone 包含 {1,1,2,3} 和 {3,2,5,1}
    cp2.printPuzzleInfo()
}

在上述代码中，PegPuzzle结构体的movesAlreadyDone字段是一个*vector.Vector类型，即一个指向vector.Vector实例的指针。当调用NewChildPegPuzzle函数并执行retVal.movesAlreadyDone = parent.movesAlreadyDone时，Go语言确实执行了值拷贝。但这个“值”是parent.movesAlreadyDone所存储的内存地址。因此，retVal.movesAlreadyDone和parent.movesAlreadyDone现在都指向了内存中同一个vector.Vector实例。

这就像你有两把钥匙，它们都能打开同一个房间。你把一把钥匙复制给了另一个人，现在你们两个人都有钥匙，但仍然是同一个房间。因此，当cp1.doMove操作修改了cp1.movesAlreadyDone指向的vector.Vector时，实际上也修改了p.movesAlreadyDone和cp2.movesAlreadyDone所指向的同一个vector.Vector。这就是为什么cp2在添加自己的移动后，会发现cp1的移动也存在的原因。

解决共享状态：实现深拷贝

为了避免这种意外的共享状态，当需要一个完全独立的数据副本时，我们必须执行“深拷贝”（deep copy）。深拷贝意味着不仅复制指针本身，还要复制指针所指向的底层数据。

对于container/vector，它提供了InsertVector方法来实现深拷贝。这个方法可以将另一个vector的所有元素插入到当前vector中。

以下是修正后的NewChildPegPuzzle函数，它通过深拷贝创建了一个独立的vector.Vector实例：

package main

import (
    "fmt"
    "container/vector"
)

type Move struct {
    x0, y0, x1, y1 int
}

type PegPuzzle struct {
    movesAlreadyDone *vector.Vector
}

func (p *PegPuzzle) InitPegPuzzle() {
    p.movesAlreadyDone = new(vector.Vector) // 正确的初始化方式
}

// NewChildPegPuzzle 函数现在执行深拷贝
func NewChildPegPuzzle(parent *PegPuzzle) *PegPuzzle {
    retVal := new(PegPuzzle)
    retVal.InitPegPuzzle() // 初始化新的 PegPuzzle 实例的 vector

    // 执行深拷贝：将父 PegPuzzle 的 movesAlreadyDone 内容复制到子 PegPuzzle 的新 vector 中
    // InsertVector(index, otherVector) 将 otherVector 的所有元素插入到当前 vector 的指定索引处
    retVal.movesAlreadyDone.InsertVector(0, parent.movesAlreadyDone)
    return retVal
}

func (p *PegPuzzle) doMove(move Move) {
    p.movesAlreadyDone.Push(move)
}

func (p *PegPuzzle) printPuzzleInfo() {
    fmt.Printf("-----------START----------------------\n")
    fmt.Printf("moves already done: %v\n", p.movesAlreadyDone)
    fmt.Printf("------------END-----------------------\n")
}

func main() {
    p := new(PegPuzzle)
    p.InitPegPuzzle()

    cp1 := NewChildPegPuzzle(p)
    cp1.doMove(Move{1, 1, 2, 3})
    cp1.printPuzzleInfo() // 输出：moves already done: [{1 1 2 3}]

    cp2 := NewChildPegPuzzle(p)
    cp2.doMove(Move{3, 2, 5, 1})
    // 此时 cp2 的 vector 是独立的，它只包含自己的移动
    cp2.printPuzzleInfo() // 输出：moves already done: [{3 2 5 1}]

    // 验证 p 仍然是原始状态
    p.printPuzzleInfo() // 输出：moves already done: [] (如果 p 未被直接修改)
}

通过retVal.InitPegPuzzle()为retVal创建了一个全新的vector.Vector实例，然后使用retVal.movesAlreadyDone.InsertVector(0, parent.movesAlreadyDone)将parent中的所有元素复制到这个新的vector中。这样，cp1和cp2各自拥有了独立的movesAlreadyDone切片，它们之间的操作互不影响。

关于container/vector包的注意事项

值得注意的是，container/vector包是Go语言早期版本提供的通用容器，在现代Go开发中已不常用。Go语言内置的切片（[]Type）提供了更高效、更简洁的替代方案，并且是Go语言推荐的数据结构。

如果使用内置切片，深拷贝通常通过copy函数或手动遍历元素实现：

// 使用内置切片进行深拷贝示例
func NewChildPegPuzzleWithSlice(parent *PegPuzzle) *PegPuzzle {
    retVal := new(PegPuzzle)
    // 假设 PegPuzzle 的 movesAlreadyDone 字段类型为 []Move
    // retVal.movesAlreadyDone = make([]Move, len(parent.movesAlreadyDone))
    // copy(retVal.movesAlreadyDone, parent.movesAlreadyDone)
    return retVal
}

此外，原问题中提到的vector.New()方法在Go的最新版本中已被移除。正确的初始化*vector.Vector的方式是使用new(vector.Vector)，这会在堆上分配一个vector.Vector结构体的零值，并返回指向它的指针。

总结与最佳实践

1. Go语言始终是值拷贝：理解这一点是避免意外共享状态的关键。当处理指针时，拷贝的是指针的值（内存地址），而不是指针所指向的底层数据。
2. 区分浅拷贝与深拷贝：当需要独立的数据副本时，必须执行深拷贝。浅拷贝（只复制指针或引用）会导致多个变量共享同一份底层数据。
3. 使用内置切片：在Go语言中，优先使用内置切片（[]Type）而非container/vector。内置切片功能强大且性能优越。
4. 初始化注意事项：对于container/vector，使用new(vector.Vector)进行初始化。对于内置切片，使用make函数或直接字面量初始化。

通过深入理解Go语言的值拷贝机制以及指针的工作原理，开发者可以更好地设计和实现数据结构，避免因意外共享状态而导致的程序错误。在需要独立数据副本的场景下，务必采取深拷贝策略。