Go 语言的赋值机制：值拷贝的真相
go 语言的设计哲学之一是其简洁性，在赋值和函数参数传递方面，它严格遵循“值拷贝”原则。这意味着当你将一个变量赋值给另一个变量，或者将一个变量作为参数传递给函数时，实际上传递的是该变量值的一个副本。
然而，对于不同的数据类型，“值”的含义有所不同：
-
基本类型（如 int, float, bool, string 等）：这些类型的值就是它们本身的数据。拷贝时会创建一个完全独立的新副本。
var a int = 10 var b int = a // b 是 a 的独立副本 b = 20 // 改变 b 不会影响 a fmt.Println(a, b) // 输出: 10 20
-
*指针类型（如 `T`）**：指针变量的值是它所指向内存地址。拷贝一个指针变量时，是拷贝了这个内存地址。这意味着新旧指针变量都指向同一块底层数据。
var x int = 10 var p1 *int = &x var p2 *int = p1 // p2 拷贝了 p1 的地址，两者都指向 x *p2 = 20 // 通过 p2 修改会影响 x fmt.Println(x) // 输出: 20
-
复合类型（如切片 []T、映射 map[K]V、通道 chan T）：这些类型在 Go 内部实现时，其变量本身存储的是一个“头部”结构。
- 切片头部：包含一个指向底层数组的指针、切片的长度和容量。
- 映射头部：包含一个指向底层哈希表结构的指针。
- 通道头部：包含一个指向通道运行时数据结构的指针。
当拷贝这些复合类型变量时，拷贝的是它们的“头部”结构，即其中包含的指针值会被复制。因此，新旧变量的头部会指向同一块底层数据。这就是为什么在外部看起来像是“引用传递”或“引用拷贝”的原因，但从 Go 的角度来看，它仍然是值拷贝——拷贝的是指针或头部结构的值。
案例分析：container/vector 的“引用”假象
原始代码中使用的 container/vector 类型，其行为与现代 Go 语言中的切片（[]T）非常相似。PegPuzzle 结构体中的 movesAlreadyDone 字段被定义为 *vector.Vector，即一个指向 vector.Vector 对象的指针。
让我们分析一下原始代码中导致“引用”假象的关键部分：
type PegPuzzle struct {
movesAlreadyDone * vector.Vector;
}
// ...
func NewChildPegPuzzle(parent *PegPuzzle) *PegPuzzle{
retVal := new(PegPuzzle);
// 问题所在：这里拷贝的是 parent.movesAlreadyDone 指针的值
// 两个 PegPuzzle 实例的 movesAlreadyDone 字段将指向同一个 vector.Vector 对象
retVal.movesAlreadyDone = parent.movesAlreadyDone;
return retVal
}
func (p *PegPuzzle) doMove(move Move){
// 对其中一个 PegPuzzle 调用 doMove，实际上是修改了共享的 vector.Vector 对象
p.movesAlreadyDone.Push(move);
}当 cp1 = NewChildPegPuzzle(p) 执行时，cp1.movesAlreadyDone 被赋值为 p.movesAlreadyDone 的值。由于 p.movesAlreadyDone 是一个 *vector.Vector 类型的指针，这里拷贝的是这个指针所指向的内存地址。因此，cp1 和 p（以及后续的 cp2）的 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 时，会发现它包含了两次 doMove 操作添加的所有元素。
实现 container/vector 的深度拷贝
要解决上述问题，实现“深拷贝”，即让 NewChildPegPuzzle 返回的 PegPuzzle 实例拥有一个独立于父级 PegPuzzle 的 movesAlreadyDone 向量，我们需要显式地复制向量的内容。
AI 舌诊面诊问诊医疗系统 + 诊疗商城系统源码是一套结合 AI 辅助诊断与商品转化的健康类程序，基于浩创云、ThinkPHP（PHP）开发，支持微信服务号与 H5 端，适合做中医舌诊面诊问答、健康建议推送以及配套诊疗商品的运营。
首先，需要注意的是，container/vector 包中的 vector.New(0) 构造函数在 Go 的新版本中已被移除。正确的做法是使用 new(vector.Vector) 来创建一个新的 vector.Vector 实例。
修正后的 InitPegPuzzle 方法应如下：
package main
import (
"fmt"
"container/vector" // 注意：此包在现代Go中已不推荐使用
)
type Move struct { x0, y0, x1, y1 int }
type PegPuzzle struct {
movesAlreadyDone * vector.Vector;
}
func (p *PegPuzzle) InitPegPuzzle(){
// 正确的初始化方式：创建新的 vector.Vector 实例
p.movesAlreadyDone = new (vector.Vector);
}接下来，为了实现 NewChildPegPuzzle 的深度拷贝，我们需要为新的 PegPuzzle 实例创建一个全新的 vector.Vector，然后将父级向量中的所有元素复制到这个新向量中。container/vector 提供了 InsertVector 方法，可以用来将一个向量的内容插入到另一个向量中。
func NewChildPegPuzzle(parent *PegPuzzle) *PegPuzzle{
retVal := new (PegPuzzle);
// 1. 为新的 PegPuzzle 实例初始化一个独立的 vector.Vector
retVal.InitPegPuzzle ();
// 2. 将父级向量的内容深度拷贝到新的向量中
// InsertVector(index, otherVector) 会将 otherVector 的所有元素插入到当前向量的指定索引处
retVal.movesAlreadyDone.InsertVector (0, parent.movesAlreadyDone);
return retVal
}
// 主函数保持不变，但现在 cp1 和 cp2 将拥有独立的 movesAlreadyDone 向量
func main() {
p := new(PegPuzzle);
p.InitPegPuzzle(); // 初始化父级谜题的向量
cp1 := NewChildPegPuzzle(p);
cp1.doMove(Move{1,1,2,3});
cp1.printPuzzleInfo(); // cp1 包含自己的移动
cp2 := NewChildPegPuzzle(p);
cp2.doMove(Move{3,2,5,1});
cp2.printPuzzleInfo(); // cp2 包含自己的移动，不含 cp1 的移动
}通过上述修改，NewChildPegPuzzle 函数现在会创建一个全新的 PegPuzzle 实例，并为其 movesAlreadyDone 字段分配一个独立的 vector.Vector 对象。然后，它会将父级 PegPuzzle 的 movesAlreadyDone 向量中的所有元素复制到这个新的向量中。这样，cp1 和 cp2 就拥有了各自独立的移动历史，互不影响。
现代 Go 语言中的切片 (Slice) 拷贝
值得强调的是，container/vector 包在现代 Go 语言中已经不推荐使用，其功能已被内置的切片（[]T）类型所取代。切片提供了更强大、更灵活且更高效的数据结构。
切片与 container/vector 类似，其赋值行为也是拷贝切片头。要对切片进行深度拷贝，最常用的方法是使用 Go 内置的 copy() 函数或手动遍历元素。
切片赋值行为示例：
package main
import "fmt"
func main() {
originalSlice := []int{1, 2, 3}
assignedSlice := originalSlice // 拷贝切片头，两者指向同一底层数组
assignedSlice[0] = 99 // 修改 assignedSlice 会影响 originalSlice
fmt.Println("Original Slice:", originalSlice) // 输出: Original Slice: [99 2 3]
fmt.Println("Assigned Slice:", assignedSlice) // 输出: Assigned Slice: [99 2 3]
}切片深度拷贝示例：
要实现切片的深度拷贝，我们需要创建一个新的切片，并使用 copy() 函数将原切片的内容复制到新切片中。copy(dst, src) 函数会从 src 切片复制元素到 dst 切片，复制的元素数量是 len(dst) 和 len(src) 中的较小值。
package main
import "fmt"
func main() {
originalSlice := []int{1, 2, 3}
// 方法一：使用 make 创建一个与原切片长度相同的新切片，然后拷贝
copiedSlice1 := make([]int, len(originalSlice))
copy(copiedSlice1, originalSlice)
// 方法二：使用 append 技巧（对于简单类型通常有效）
// copiedSlice2 := append([]int(nil), originalSlice...) // 更简洁，但可能创建不必要的容量
// 或者直接初始化一个空切片然后 append
copiedSlice2 := []int{}
copiedSlice2 = append(copiedSlice2, originalSlice...)
copiedSlice1[0] = 99
copiedSlice2[1] = 88
fmt.Println("Original Slice:", originalSlice) // 输出: Original Slice: [1 2 3]
fmt.Println("Copied Slice 1:", copiedSlice1) // 输出: Copied Slice 1: [99 2 3]
fmt.Println("Copied Slice 2:", copiedSlice2) // 输出: Copied Slice 2: [1 88 3]
}对于包含复杂类型（如结构体指针）的切片，copy() 函数执行的是浅拷贝，即它只拷贝了指针本身，而不是指针指向的数据。在这种情况下，如果需要深度拷贝，你可能需要手动遍历切片，并对每个元素进行递归的深度拷贝。
总结与最佳实践
理解 Go 语言中复合类型（尤其是切片和指针）的赋值行为至关重要。虽然 Go 始终采用值拷贝，但对于这些类型，拷贝的“值”是其内部的指针或头部结构，这使得新旧变量可能共享同一块底层数据。
- 浅拷贝（默认行为）：直接赋值切片、映射或指针，会复制其头部或地址，导致多个变量引用同一份底层数据。修改其中一个变量可能影响所有引用该数据的变量。
- 深拷贝（手动实现）：当需要确保数据独立性时，必须显式地创建新的底层数据结构，并将原有数据内容复制过去。对于切片，推荐使用 make 配合 copy() 函数。对于 container/vector，可以使用 InsertVector。
- 弃用 container/vector：在现代 Go 开发中，应优先使用内置的切片 ([]T) 代替 container/vector，因为它更高效、更符合 Go 的设计理念。
在设计数据结构和函数时，请始终考虑你的数据是否需要独立性。如果需要，务必执行明确的深拷贝操作，以避免因共享底层数据而导致的意外副作用。
