Go语言中Map遍历时获取成员地址的陷阱与解决方案

package main

import "fmt"

// Result 示例结构体
type Result struct {
    ID   int
    Port int
}

func main() {
    // 示例Map，存储的是Result结构体的值
    m := map[string]Result{
        "server1": {ID: 1, Port: 6379},
        "server2": {ID: 2, Port: 6380},
    }

    // 尝试存储Map值的指针
    r := make([]*Result, 0, len(m)) // 初始化一个存储*Result的切片

    i := 0
    for key, res := range m { // res是Map中值的副本
        fmt.Printf("Iteration %d (key: %s): res value = %+v, res address = %p\n", i, key, res, &res)
        r = append(r, &res) // 将循环变量res的地址添加到切片
        i++
    }

    fmt.Println("\n--- 存储的指针切片内容 ---")
    for idx, ptr := range r {
        if ptr != nil {
            fmt.Printf("r[%d] points to %p, dereferenced value = %+v\n", idx, ptr, *ptr)
        } else {
            fmt.Printf("r[%d] is nil\n", idx)
        }
    }
    // 观察输出，会发现r中所有指针都指向同一个地址，并且其值都是Map中最后一个元素的值
}

package main

import "fmt"

type Result struct {
    ID   int
    Port int
}

func main() {
    // 方案一：Map直接存储*Result指针
    mPtr := map[string]*Result{
        "server1": {ID: 1, Port: 6379},
        "server2": {ID: 2, Port: 6380},
    }

    rPtrs := make([]*Result, 0, len(mPtr))
    fmt.Println("\n--- 方案一：Map存储指针 ---")
    for key, resPtr := range mPtr { // resPtr已经是*Result类型
        fmt.Printf("Iteration (key: %s): resPtr value = %+v, resPtr address = %p\n", key, *resPtr, resPtr)
        rPtrs = append(rPtrs, resPtr) // 直接添加resPtr到切片
    }

    fmt.Println("\n--- 存储的指针切片内容 (方案一) ---")
    for idx, ptr := range rPtrs {
        if ptr != nil {
            fmt.Printf("rPtrs[%d] points to %p, dereferenced value = %+v\n", idx, ptr, *ptr)
        } else {
            fmt.Printf("rPtrs[%d] is nil\n", idx)
        }
    }
    // 此时，每个指针都指向Map中对应元素的独立内存地址
}

package main

import "fmt"

type Result struct {
    ID   int
    Port int
}

func main() {
    // 方案二：Map存储Result值类型
    mVal := map[string]Result{
        "server1": {ID: 1, Port: 6379},
        "server2": {ID: 2, Port: 6380},
    }

    rVals := make([]*Result, 0, len(mVal))
    fmt.Println("\n--- 方案二：Map存储值，循环内创建副本 ---")
    for key, resVal := range mVal { // resVal是Map中值的副本
        // 关键步骤：创建一个新的局部变量来存储resVal的副本
        temp := resVal
        fmt.Printf("Iteration (key: %s): resVal value = %+v, temp address = %p\n", key, resVal, &temp)
        rVals = append(rVals, &temp) // 将temp的地址添加到切片
    }

    fmt.Println("\n--- 存储的指针切片内容 (方案二) ---")
    for idx, ptr := range rVals {
        if ptr != nil {
            fmt.Printf("rVals[%d] points to %p, dereferenced value = %+v\n", idx, ptr, *ptr)
        } else {
            fmt.Printf("rVals[%d] is nil\n", idx)
        }
    }
    // 此时，每个指针都指向一个独立的临时变量，存储着对应迭代的值
}