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实例。
立即学习“go语言免费学习笔记（深入）”；
这就像你有两把钥匙，它们都能打开同一个房间。你把一把钥匙复制给了另一个人，现在你们两个人都有钥匙，但仍然是同一个房间。因此，当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结构体的零值，并返回指向它的指针。
总结与最佳实践
- Go语言始终是值拷贝：理解这一点是避免意外共享状态的关键。当处理指针时，拷贝的是指针的值（内存地址），而不是指针所指向的底层数据。
- 区分浅拷贝与深拷贝：当需要独立的数据副本时，必须执行深拷贝。浅拷贝（只复制指针或引用）会导致多个变量共享同一份底层数据。
- 使用内置切片：在Go语言中，优先使用内置切片（[]Type）而非container/vector。内置切片功能强大且性能优越。
- 初始化注意事项：对于container/vector，使用new(vector.Vector)进行初始化。对于内置切片，使用make函数或直接字面量初始化。
通过深入理解Go语言的值拷贝机制以及指针的工作原理，开发者可以更好地设计和实现数据结构，避免因意外共享状态而导致的程序错误。在需要独立数据副本的场景下，务必采取深拷贝策略。
