Golang递归中传递结构体引用遇到的问题

这是一个典型的切片引用问题。在Go中，切片是引用类型，当你在递归中传递包含切片的结构体时，实际上传递的是对底层数组的引用。

问题分析：

1. bOrigIn := bIn 创建的是结构体的浅拷贝，切片字段仍然指向相同的底层数组
2. mm(bIn) 函数可能修改了切片的底层数据
3. 递归调用中的修改会影响到所有共享相同底层数组的变量

示例代码说明问题：

package main

import "fmt"

type Data struct {
    S []int
    W []int
}

func mm(d Data) Data {
    // 修改切片元素 - 这会影响到原始数据
    if len(d.S) > 0 {
        d.S[0] = 999
    }
    return d
}

func play(d Data, depth int) {
    if depth >= 3 {
        return
    }
    
    fmt.Printf("Depth %d - Before: d.S[0] = %d\n", depth, d.S[0])
    
    bNew := mm(d)
    bOrigIn := d  // 浅拷贝，切片仍然共享底层数组
    
    fmt.Printf("Depth %d - After mm: d.S[0] = %d, bOrigIn.S[0] = %d\n", 
        depth, d.S[0], bOrigIn.S[0])
    
    play(bNew, depth+1)
    
    fmt.Printf("Depth %d - After recursion: d.S[0] = %d, bOrigIn.S[0] = %d\n", 
        depth, d.S[0], bOrigIn.S[0])
}

func main() {
    d := Data{
        S: []int{1, 2, 3},
        W: []int{4, 5, 6},
    }
    play(d, 0)
}

输出会显示所有变量都被修改了，因为它们共享相同的底层数组。

解决方案：深度拷贝结构体

import "golang.org/x/exp/slices"

func deepCopyData(d Data) Data {
    return Data{
        S: slices.Clone(d.S),  // Go 1.21+ 或使用 exp/slices
        W: slices.Clone(d.W),
    }
}

// 或者手动实现
func deepCopyDataManual(d Data) Data {
    sCopy := make([]int, len(d.S))
    wCopy := make([]int, len(d.W))
    copy(sCopy, d.S)
    copy(wCopy, d.W)
    return Data{
        S: sCopy,
        W: wCopy,
    }
}

// 在递归中使用
func play(d Data, depth int) {
    if depth >= 3 {
        return
    }
    
    // 创建深度拷贝
    bNew := deepCopyData(d)
    bNew = mm(bNew)  // 现在修改不会影响原始数据
    
    bOrigIn := deepCopyData(d)  // 深度拷贝保持原始状态
    
    play(bNew, depth+1)
    
    // 现在 d 和 bOrigIn 保持不变
}

对于包含结构体切片的深度拷贝：

type Item struct {
    String1 string
    String2 string
    Bool    bool
}

type Container struct {
    S []Item
    W []Item
}

func deepCopyContainer(c Container) Container {
    sCopy := make([]Item, len(c.S))
    wCopy := make([]Item, len(c.W))
    
    for i := range c.S {
        sCopy[i] = c.S[i]  // Item 是值类型，会被拷贝
    }
    
    for i := range c.W {
        wCopy[i] = c.W[i]
    }
    
    return Container{
        S: sCopy,
        W: wCopy,
    }
}

关键点：

1. Go中的切片赋值是浅拷贝，只拷贝切片头（指针、长度、容量）
2. 结构体赋值会拷贝所有字段，但对于切片字段只拷贝切片头
3. 递归中需要显式进行深度拷贝来隔离数据修改
4. 使用 copy() 函数或 slices.Clone() 来复制切片内容