深入理解Go语言中切片与指针的陷阱：变量意外修改解析与规避

type Grammar struct {
    Rules []*Rule // 假设 Rules 是 Rule 指针的切片
    // ... 其他字段
}

type Rule struct {
    Src   string
    Right []string // 关键字段：字符串切片
    // ... 其他字段
}

// 假设 ToGrammar 函数将 cfg 转换为 Grammar 结构体
func ToGrammar(cfg string) *Grammar { /* ... */ return &Grammar{} }

// 假设 OstarCF 函数执行一些操作并返回新的 QRS 切片
func OstarCF(Qs []QRS, R []string, nD map[string]bool, cD map[string][]string) []QRS {
    symbols := []string{}
    for _, r := range R {
        symbols = append(symbols, cD[r]...)
    }
    product := []QRS{}
    for _, Q := range Qs {
        a := Q.one
        b := Q.two
        c := Q.three
        if len(c) > 0 && CheckStr(c[0], symbols) {
            b = append(b, c[0])
            np := QRS{
                one:   a,
                two:   b,
                three: c[1:],
            }
            product = append(product, np)

            for len(np.three) > 0 && nD[np.three[0]] == true {
                np.two = append(np.two, np.three[0])
                np = QRS{
                    one:   np.one,
                    two:   np.two,
                    three: np.three[1:],
                }
                product = append(product, np)
            }
        }
    }
    return product
}

// 假设 Grammar 结构体有一个 ChainsTo 方法
func (g Grammar) ChainsTo(nullables map[string]bool) map[string][]string {
    // ... 内部实现，可能包含对 g.Rules 的迭代和修改
    // 关键点：这个方法接收的是 Grammar 的值拷贝

    // 模拟 ChainsTo 中可能导致问题的一段逻辑
    // 假设在某个循环中处理 rule.Right
    // for _, rule := range g.Rules {
    //    rhs := rule.Right // rhs 共享 rule.Right 的底层数组
    //    // 假设在某个地方通过切片操作和 append 改变了 rhs 的内容
    //    // 例如：
    //    // ns := rhs[:i]
    //    // ns = append(ns, rhs[i+1:]...) // 如果 append 发生在原有容量内，会覆盖原始数据
    // }
    return make(map[string][]string) // 实际返回一个 map
}

func main() {
    cfg2 := `S -> DP,VP
VP -> V,DP
VP -> V,DP,AdvP`

    or2 := []QRS{}
    g2 := ToGrammar(cfg2)
    fmt.Printf("初始规则:\n%s\n", g2)

    // 在这里调用 ChainsTo，并传入 g2.Nullables()
    // ChainsTo 方法内部对切片的操作，意外地改变了 g2.Rules 中的 Rule 对象的 Right 字段
    for _, rule := range g2.Rules {
        q := QRS{
            one:   rule.Src,
            two:   []string{},
            three: rule.Right,
        }
        // OstarCF 本身可能不直接修改 rule，但 ChainsTo 内部的逻辑是关键
        or2 = append(or2, OstarCF([]QRS{q}, []string{"sees"}, g2.Nullables(), g2.ChainsTo(g2.Nullables()))...)
    }

    fmt.Printf("修改后规则:\n%s\n", g2) // 这里的 g2.Rules 发生了意外改变
}

// 示例：切片头部拷贝，共享底层数组
func modifySlice(s []int) {
    s[0] = 99 // 修改 s[0] 会影响原始切片
    s = append(s, 4, 5) // 如果 append 导致扩容，s 会指向新的底层数组，不再影响原始切片
                       // 但如果容量足够，则可能在原底层数组上修改
}

func main() {
    original := []int{1, 2, 3}
    fmt.Println("Original before:", original) // [1 2 3]
    modifySlice(original)
    fmt.Println("Original after:", original)  // [99 2 3] (如果 append 没扩容，可能还会看到更多变化)
}

// ChainsTo 方法的改进示例 (仅关注关键部分)
func (g Grammar) ChainsTo(nullables map[string]bool) map[string][]string {
    result := make(map[string][]string)

    for _, rule := range g.Rules {
        // 关键改进：在操作 rule.Right 之前，先进行深拷贝
        // 确保 rhs 是一个独立的切片，拥有自己的底层数组
        originalRight := rule.Right

        // 如果需要修改 originalRight 的某个版本，例如删除元素或重排
        // 不直接使用 originalRight，而是创建一个新的切片

        // 假设原始逻辑是构建一个新的切片 ns，其中移除了某个元素
        // 错误的做法 (会修改原始 rule.Right):
        // rhs := originalRight
        // ns := rhs[:i]
        // ns = append(ns, rhs[i+1:]...)

        // 正确的做法 (显式深拷贝):
        // 1. 创建一个足够容量的新切片
        newRHS := make([]string, 0, len(originalRight))

        // 2. 将原始切片的部分内容复制到新切片
        // 假设要移除索引为 i 的元素
        i := 0 // 示例索引
        newRHS = append(newRHS, originalRight[:i]...)
        newRHS = append(newRHS, originalRight[i+1:]...)

        // 现在可以安全地使用 newRHS 进行后续操作，它不会影响 rule.Right
        // ... 使用 newRHS ...

        // 示例：将某个结果存入 result map
        // result[rule.Src] = newRHS 
    }
    return result
}