Go语言中如何返回切片元素指针以同步修改原结构体属性

核心问题是你当前传递和存储的是Char结构体的值副本，所有修改只会作用在副本上，无法同步到原切片。改用*Char指针类型，就能让所有操作指向原结构体实例，修改自然会同步。

以下是具体修改步骤：

1. 调整MatchMaking函数 #

将返回类型改为map[[2]*Char]bool，存储指针对而非结构体副本；同时修改内部配对逻辑，直接处理指针：

func MatchMaking(arr []*structs.Char) map[[2]*structs.Char]bool {
    m := make(map[[2]*structs.Char]bool)
    for _, v1 := range arr {
        for _, v2 := range arr {
            if v1.Name == v2.Name {
                continue
            }
            // 按名称排序指针对，避免重复配对
            var sortedPair [2]*structs.Char
            if v1.Name < v2.Name {
                sortedPair = [2]*structs.Char{v1, v2}
            } else {
                sortedPair = [2]*structs.Char{v2, v1}
            }
            if _, ok := m[sortedPair]; !ok {
                m[sortedPair] = true
            }
        }
    }
    return m
}

2. 修改InputCharacters返回指针切片 #

让函数返回[]*Char，确保原切片存储的是结构体指针：

func InputCharacters() []*structs.Char {
    var charSlice []*structs.Char = []*structs.Char{}
    var reader = bufio.NewReader(os.Stdin)

    for {
        fmt.Println("Enter a character name (or quit/q to finish):")
        name, err := reader.ReadString('\n')
        name = strings.TrimSpace(name)
        if err != nil {
            fmt.Printf("Reading error: %v", err)
        }

        if name == "quit" || name == "q" {
            return charSlice
        }

        // 移除重名元素
        for i := range charSlice {
            if charSlice[i].Name == name {
                charSlice = append(charSlice[:i], charSlice[i+1:]...)
                break
            }
        }

        // 添加结构体指针到切片
        charSlice = append(charSlice, &structs.Char{Name: name, Score: 0})
    }
}

3. 更新Voting函数的参数与逻辑 #

接收指针对的map，直接修改指针指向的原结构体Score：

func Voting(pairs map[[2]*structs.Char]bool) []*structs.Char {
    var reader = bufio.NewReader(os.Stdin)

    for pair := range pairs {
        fmt.Println("Vote for your favourite (0 for left, 1 for right)")
        fmt.Printf("%v - %v\n", pair[0].Name, pair[1].Name)
        input, err := reader.ReadString('\n')
        input = strings.TrimSpace(input)
        if err != nil {
            fmt.Printf("Reading error: %v", err)
            continue
        }
        vote, err := strconv.ParseInt(input, 10, 8)
        if err != nil {
            fmt.Printf("Invalid vote, please enter 0 or 1: %v", err)
            continue
        }
        switch vote {
        case 0:
            pair[0].Score++
        case 1:
            pair[1].Score++
        default:
            fmt.Println("Invalid vote, please enter 0 or 1")
        }
    }

    // 收集去重后的角色指针
    var charArr []*structs.Char = make([]*structs.Char, 0)
    seen := make(map[string]bool)
    for pair := range pairs {
        if !seen[pair[0].Name] {
            charArr = append(charArr, pair[0])
            seen[pair[0].Name] = true
        }
        if !seen[pair[1].Name] {
            charArr = append(charArr, pair[1])
            seen[pair[1].Name] = true
        }
    }
    return charArr
}

4. 调整main函数的遍历逻辑 #

因为返回的是指针切片，直接访问指针字段即可：

func main() {
    baseSlice := InputCharacters()
    matchups := MatchMaking(baseSlice)
    voting := Voting(matchups)
    n := 0
    for _, v := range voting {
        fmt.Printf("%d: %v(%v)\n", n, v.Name, v.Score)
        n++
    }
    // 原切片的Score已同步更新
    fmt.Println("\nOriginal slice with updated scores:")
    for _, v := range baseSlice {
        fmt.Printf("%v(%v)\n", v.Name, v.Score)
    }
}

关键原理说明 #

• Go语言中，结构体值的赋值、传递都会产生副本，修改副本不影响原对象；
• 使用*Char指针后，所有操作都是针对原结构体的内存地址引用，修改指针指向的字段会直接作用于原对象；
• 指针可以作为map的key，这里通过排序后的指针对实现配对去重，逻辑通顺。

内容的提问来源于stack exchange，提问作者BDealer