Go语言中切片修改的深度解析：值传递与引用传递的陷阱与实践

package main

import (
    "fmt"
)

// 定义Pair结构体，用于表示一对整数
type Pair struct {
    a int
    b int
}

// 定义PairAndFreq结构体，包含Pair和其频率
type PairAndFreq struct {
    Pair
    Freq int
}

// 定义PairSlice类型，是PairAndFreq的切片
type PairSlice []PairAndFreq

// 定义PairSliceSlice类型，是PairSlice的切片，用于演示多层切片
type PairSliceSlice []PairSlice

// Weed方法，调用weed函数处理内部的PairSlice
func (pss PairSliceSlice) Weed() {
    fmt.Println("调用weed前:", pss[0])
    weed(pss[0]) // 问题发生在这里：pss[0]被值传递
    fmt.Println("调用weed后:", pss[0])
}

// weed函数，尝试对传入的PairSlice进行去重和频率统计
func weed(ps PairSlice) {
    m := make(map[Pair]int)

    // 统计每个Pair的频率
    for _, v := range ps {
        m[v.Pair]++
    }

    // 关键问题所在：重新赋值ps，创建了一个新的局部切片头部
    ps = ps[:0] // 将ps重置为空切片，但这个操作只影响局部变量ps

    // 将统计结果追加到局部切片ps中
    for k, v := range m {
        ps = append(ps, PairAndFreq{k, v})
    }
    fmt.Println("weed函数内部修改后:", ps) // 这里打印的是局部变量ps
}

func main() {
    pss := make(PairSliceSlice, 12)
    // 初始化pss[0]，包含两个相同的PairAndFreq元素
    pss[0] = PairSlice{PairAndFreq{Pair{1, 1}, 1}, PairAndFreq{Pair{1, 1}, 1}}

    pss.Weed()
}

调用weed前: [{{1 1} 1} {{1 1} 1}]
weed函数内部修改后: [{{1 1} 2}]
调用weed后: [{{1 1} 1} {{1 1} 1}]

package main

import (
    "fmt"
)

type Pair struct {
    a int
    b int
}

type PairAndFreq struct {
    Pair
    Freq int
}

type PairSlice []PairAndFreq

type PairSliceSlice []PairSlice

func (pss PairSliceSlice) WeedCorrectly() {
    fmt.Println("调用weedPtr前:", pss[0])
    weedPtr(&pss[0]) // 传递pss[0]的地址
    fmt.Println("调用weedPtr后:", pss[0])
}

// weedPtr函数接收一个指向PairSlice的指针
func weedPtr(ps *PairSlice) { // 参数类型改为 *PairSlice
    m := make(map[Pair]int)

    // 遍历时需要解引用指针
    for _, v := range *ps {
        m[v.Pair]++
    }

    // 修改原始切片：解引用指针后对其进行操作
    *ps = (*ps)[:0] // 通过指针修改原始切片的头部

    for k, v := range m {
        *ps = append(*ps, PairAndFreq{k, v}) // 通过指针修改原始切片
    }
    fmt.Println("weedPtr函数内部修改后:", *ps) // 打印解引用后的切片
}

func main() {
    pss := make(PairSliceSlice, 12)
    pss[0] = PairSlice{PairAndFreq{Pair{1, 1}, 1}, PairAndFreq{Pair{1, 1}, 1}}

    pss.WeedCorrectly()
}

调用weedPtr前: [{{1 1} 1} {{1 1} 1}]
weedPtr函数内部修改后: [{{1 1} 2}]
调用weedPtr后: [{{1 1} 2}]

package main

import (
    "fmt"
)

type Pair struct {
    a int
    b int
}

type PairAndFreq struct {
    Pair
    Freq int
}

type PairSlice []PairAndFreq

type PairSliceSlice []PairSlice

func (pss PairSliceSlice) WeedReturnNew() {
    fmt.Println("调用weedReturn前:", pss[0])
    // 调用函数并用返回值更新pss[0]
    pss[0] = weedReturn(pss[0])
    fmt.Println("调用weedReturn后:", pss[0])
}

// weedReturn函数返回一个新的PairSlice
func weedReturn(ps PairSlice) PairSlice {
    m := make(map[Pair]int)

    for _, v := range ps {
        m[v.Pair]++
    }

    // 创建一个新的切片来存储结果
    newPs := make(PairSlice, 0, len(m))
    for k, v := range m {
        newPs = append(newPs, PairAndFreq{k, v})
    }
    fmt.Println("weedReturn函数内部生成新切片:", newPs)
    return newPs // 返回新切片
}

func main() {
    pss := make(PairSliceSlice, 12)
    pss[0] = PairAndFreq{Pair{1, 1}, 1}, PairAndFreq{Pair{1, 1}, 1}}

    pss.WeedReturnNew()
}

调用weedReturn前: [{{1 1} 1} {{1 1} 1}]
weedReturn函数内部生成新切片: [{{1 1} 2}]
调用weedReturn后: [{{1 1} 2}]