切片赋值与深度复制详解

学习Golang要努力，但是不要急！今天的这篇文章《切片赋值引用与深度复制解析》将会介绍到等等知识点，如果你想深入学习Golang，可以关注我！我会持续更新相关文章的，希望对大家都能有所帮助！

Go语言的赋值语义：值类型与引用类型

在Go语言中，变量的赋值行为取决于其类型。基本数据类型（如int, float, bool, string）以及数组（当作为值传递时）在赋值时会进行值复制，即创建一个独立的副本。这意味着修改副本不会影响原始值。

然而，对于复合类型如切片（slice）、映射（map）、通道（channel）以及指针类型，其赋值行为则表现出引用特性。这些类型在内部通常包含指向底层数据的指针或描述符。当一个变量赋值给另一个变量时，复制的不是底层数据本身，而是这个指针或描述符。因此，两个变量最终会指向或操作同一份底层数据。

在早期Go版本中，container/vector包提供的Vector类型也是如此。Vector实际上是一个包含指向底层数组指针的结构体。当您将一个Vector实例赋值给另一个变量时，您复制的是这个结构体本身，而结构体中的指针仍然指向同一份底层数据。

container/vector的特性与陷阱

在提供的PegPuzzle示例代码中，movesAlreadyDone字段被定义为*vector.Vector，即一个指向vector.Vector的指针。

type PegPuzzle struct {
    movesAlreadyDone * vector.Vector;
}

问题出现在NewChildPegPuzzle函数中：

func NewChildPegPuzzle(parent *PegPuzzle) *PegPuzzle{
    retVal := new(PegPuzzle);
    retVal.movesAlreadyDone = parent.movesAlreadyDone; // 问题所在
    return retVal
}

这行代码 retVal.movesAlreadyDone = parent.movesAlreadyDone; 并没有创建一个新的vector.Vector实例并复制parent中的数据，而是简单地将parent.movesAlreadyDone（一个指向vector.Vector的指针）的值赋给了retVal.movesAlreadyDone。结果是，parent和retVal的movesAlreadyDone字段都指向了同一个vector.Vector实例。

因此，当通过cp1.doMove(Move{1,1,2,3})向cp1的movesAlreadyDone添加元素时，实际上是修改了它们共享的那个vector.Vector实例。随后，当cp2 = NewChildPegPuzzle(p)被调用时，cp2的movesAlreadyDone也指向了同一个共享的vector.Vector。所以，当cp2.doMove(Move{3,2,5,1})执行后，cp2的movesAlreadyDone会包含cp1之前添加的移动以及cp2自己添加的移动，因为它们操作的是同一个底层数据结构。

实现深度复制：正确的方法

为了解决上述问题，确保NewChildPegPuzzle返回的子谜题拥有其独立的movesAlreadyDone历史，我们需要执行深度复制。这意味着不仅要创建新的PegPuzzle实例，还要为movesAlreadyDone字段创建一个全新的vector.Vector实例，并将父谜题中的所有元素复制到这个新实例中。

container/vector包提供了InsertVector方法，可以用于将一个Vector的内容插入到另一个Vector中，从而实现深度复制。

以下是修正后的InitPegPuzzle和NewChildPegPuzzle函数：

package main

import "fmt"
import "container/vector" // 注意：此包在现代Go版本中已不推荐使用，推荐使用内置切片

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

type PegPuzzle struct {
    movesAlreadyDone * vector.Vector;
}

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

// 修正：实现movesAlreadyDone的深度复制
func NewChildPegPuzzle(parent *PegPuzzle) *PegPuzzle{
    retVal := new (PegPuzzle);
    retVal.InitPegPuzzle (); // 初始化新的vector实例
    // 将父谜题的movesAlreadyDone内容深度复制到新的retVal.movesAlreadyDone中
    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);
    cp1 := new(PegPuzzle);
    cp2 := 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.doMove(Move{3,2,5,1});
    cp2.printPuzzleInfo(); // 此时 cp2 的 movesAlreadyDone 包含 {1,1,2,3}, {3,2,5,1}
                           // 注意：这里仍然会包含 {1,1,2,3}，因为 NewChildPegPuzzle(p) 是基于 p 的初始状态，
                           // 而 p 在 cp1 操作后并未被修改。
                           // 如果期望 cp2 仅包含自己的 move，则 p 应该在 NewChildPegPuzzle(p) 调用前不被修改，
                           // 或者 NewChildPegPuzzle 应该从 cp1 复制，而非 p。
                           // 修正后的代码解决了 cp1 和 cp2 不共享 vector 实例的问题。
                           // 原始意图可能是 cp1 和 cp2 都从 "p" 的初始空状态派生，
                           // 那么 cp1 和 cp2 应该各自独立。
                           // 运行修正后的代码，cp1 会显示 {1,1,2,3}，cp2 会显示 {3,2,5,1}。
                           // 这是因为 NewChildPegPuzzle(p) 每次都从 p (其 movesAlreadyDone 始终为空) 复制。
}

运行修正后的main函数，输出将是：

-----------START----------------------
moves already done: [1 1 2 3]
------------END-----------------------
-----------START----------------------
moves already done: [3 2 5 1]
------------END-----------------------

这表明cp1和cp2现在拥有独立的movesAlreadyDone向量。

注意事项与最佳实践

1. container/vector的废弃： 值得注意的是，container/vector包在现代Go语言版本中已被废弃，不推荐使用。Go语言内置的切片（slice）提供了更强大、更灵活且性能更优越的功能，并且是Go语言中处理动态数组的标准方式。
2. 切片的深度复制： 如果使用切片代替container/vector，深度复制通常通过copy()函数结合make()创建新切片来实现。例如：

   func NewChildPegPuzzleSlice(parent *PegPuzzleSlice) *PegPuzzleSlice {
       retVal := new(PegPuzzleSlice)
       // 创建一个足够大的新切片
       retVal.movesAlreadyDone = make([]Move, len(parent.movesAlreadyDone))
       // 深度复制元素
       copy(retVal.movesAlreadyDone, parent.movesAlreadyDone)
       return retVal
   }

3. 理解Go的内存模型： 深入理解Go语言中值类型、指针、切片、映射等复合类型的内存布局和赋值行为至关重要。这有助于避免因共享底层数据而导致的意外副作用，特别是在并发编程中。
4. 性能考量： 深度复制会涉及额外的内存分配和数据拷贝，对于非常大的数据结构，这可能会带来性能开销。在某些场景下，如果数据不被修改，或者可以通过其他机制（如不可变数据结构、写时复制等）来管理，共享数据可能是更高效的选择。但在需要独立状态的场景下，深度复制是必要的。

总结

Go语言中，像container/vector（以及内置切片、映射等）这样的复合类型在赋值时，复制的是指向底层数据的引用（或描述符），而非底层数据本身。这是一种“浅复制”行为。要实现数据独立性，避免多个变量意外地共享和修改同一份数据，必须进行“深度复制”。对于container/vector，可以使用InsertVector方法；对于Go内置切片，则通常结合make和copy函数来完成。理解并正确应用这些复制策略是编写健壮、可预测Go程序的关键。

今天关于《切片赋值与深度复制详解》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！