Go语言中切片与指针的陷阱：理解结构体字段意外修改的根源与解决方案

type QRS struct {
    one   string
    two   []string
    three []string
}

type Rule struct {
    Src   string
    Right []string // 这是一个切片
}

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

// 假设 cfg2 是一个初始化好的语法配置
// g2 := ToGrammar(cfg2)
// fmt.Printf("修改前规则: %s\n", g2) // 期望输出: S -> DP,VP; VP -> V,DP; VP -> V,DP,AdvP

// 迭代 g2.Rules 并调用 OstarCF 函数
for _, rule := range g2.Rules {
    q := QRS{
        one:   rule.Src,
        two:   []string{},
        three: rule.Right, // 这里的 rule.Right 被用于初始化 QRS
    }
    // OstarCF 函数内部可能对 QRS 的 three 字段进行了操作
    // or2 = append(or2, OstarCF([]QRS{q}, []string{"sees"}, g2.Nullables(), g2.ChainsTo(g2.Nullables()))...)
}

// fmt.Printf("修改后规则: %s\n", g2) // 实际输出可能变为: S -> VP,VP; VP -> DP,DP; VP -> AdvP,AdvP,AdvP

s1 := []string{"a", "b", "c"}
s2 := s1 // s2 和 s1 共享底层数组
s2[0] = "x"
fmt.Println(s1) // 输出: [x b c]

// 假设这是 ChainsTo 方法的一部分
func (g Grammar) ChainsTo(...) map[string][]string { // g 是 Grammar 的一个副本
    // ...
    for _, rule := range g.Rules { // rule 是 *Rule 类型，指向原始 Rule 对象
        rhs := rule.Right // rhs 是 rule.Right 的切片头部副本，它们共享底层数组

        // 关键步骤：创建新切片 ns，可能重用 rhs 的底层数组
        // 假设 i=0
        ns := rhs[:i] // 如果 i=0，ns 是一个空切片，但其底层数组仍是 rhs 的底层数组
        ns = append(ns, rhs[i+1:]...) // 当 append 发生时，如果 ns 容量足够，它会直接覆盖底层数组的元素

        // ... ns 被用于构建返回结果，但此时它可能已经修改了 rule.Right 的底层数据
    }
    // ...
}

// 修正前的代码片段 (在 ChainsTo 方法内部)
// rhs := rule.Right
// ns := rhs[:i] // 此处 ns 仍与 rhs 共享底层数组
// ns = append(ns, rhs[i+1:]...)

// 修正后的代码片段
rhs := rule.Right
// 显式创建一个新的切片 ns，分配一个新的底层数组，容量与 rhs 相同
ns := make([]string, 0, len(rhs)) 
ns = append(ns, rhs[:i]...) // 将 rhs 的前 i 个元素追加到 ns
ns = append(ns, rhs[i+1:]...) // 将 rhs 的剩余元素追加到 ns

package main

import "fmt"

// Rule 结构体，包含一个字符串切片
type Rule struct {
    Src   string
    Right []string
}

// Grammar 结构体，包含 Rule 指针的切片
type Grammar struct {
    Rules []*Rule
}

// simulateChainsTo 模拟 ChainsTo 方法中的切片操作
// 注意：这里为了简化，直接传入了 *Rule，实际 ChainsTo 是 Grammar 的方法
func simulateChainsTo(rule *Rule, i int) {
    fmt.Printf("  simulateChainsTo 内部 - 初始 rule.Right: %v\n", rule.Right)

    // 问题代码：rhs 和 ns 可能共享底层数组
    // rhs := rule.Right
    // ns := rhs[:i] // 如果 i=0, ns 仍指向 rhs 的底层数组
    // ns = append(ns, rhs[i+1:]...)
    // fmt.Printf("  simulateChainsTo 内部 - 错误操作后 ns: %v\n", ns)

    // 修正代码：显式创建新的底层数组
    rhs := rule.Right
    ns := make([]string, 0, len(rhs)) // 关键：分配新的底层数组
    ns = append(ns, rhs[:i]...)
    ns = append(ns, rhs[i+1:]...)
    fmt.Printf("  simulateChainsTo 内部 - 正确操作后 ns: %v\n", ns)

    // 在实际 ChainsTo 中，ns 可能被用于构建其他结构，但不会影响 rule.Right
    // 这里我们只是打印 ns，不再对 rule.Right 进行赋值
}

func main() {
    // 初始化 Grammar
    rule1 := &Rule{Src: "S", Right: []string{"DP", "VP"}}
    rule2 := &Rule{Src: "VP", Right: []string{"V", "DP"}}
    rule3 := &Rule{Src: "VP", Right: []string{"V", "DP", "AdvP"}}

    g := &Grammar{
        Rules: []*Rule{rule1, rule2, rule3},
    }

    fmt.Println("--- 初始状态 ---")
    for idx, r := range g.Rules {
        fmt.Printf("Rule %d: Src=%s, Right=%v\n", idx, r.Src, r.Right)
    }

    fmt.Println("\n--- 模拟调用 simulateChainsTo (例如 i=0) ---")
    // 假设在循环中，我们处理 rule1，并模拟移除第一个元素
    // 注意：这里的 simulateChainsTo 只是为了演示切片操作，
    // 实际 OstarCF 函数可能不会直接修改 rule，但其内部调用的 ChainsTo 方法会
    simulateChainsTo(g.Rules[0], 0) // 模拟移除第一个元素 "DP"

    fmt.Println("\n--- 修正后状态 (rule.Right 不应改变) ---")
    for idx, r := range g.Rules {
        fmt.Printf("Rule %d: Src=%s, Right=%v\n", idx, r.Src, r.Right)
    }

    // 如果使用错误代码，这里的 Rule 0 的 Right 字段会变成 [VP]，而不是 [DP VP]
    // 修正后，Rule 0 的 Right 字段仍是 [DP VP]
}