Why do all values ​​in the map point to the same memory address when using for range loop to loop through slices in Go?

Traps between for...range loop and map in Go language

This article analyzes a common Go programming problem, which involves the usage of structures, slices, and maps, and explains why when using for...range loop to traverse slices, all values ​​in the map point to the same memory address. Understanding this problem is crucial to mastering the memory management and reference types of Go.

Problem description:

The following code snippet demonstrates the problem:

 type student struct {
    name string
    age int
}

func main() {
    m := make(map[string]*student)
    stus := []student{
        {name: "pprof.cn", age: 18},
        {name: "test", age: 23},
        {name: "Blog", age: 28},
    }

    for _, stu := range stu {
        m[stu.name] = &stu
    }
    for k, v := range m {
        fmt.Println(k, "=>", v.name)
    }
}

The run results show that all v.name values ​​are "blog". This is because when the for...range loop traverses the slice, stu variable is a temporary variable inside a loop, and its memory address points to the same memory location in each iteration. Therefore, m[stu.name] = &stu actually points all values ​​in the map to the memory address of the same student structure, and this address points to the last element "blog" after the loop ends.

Solution:

To avoid this problem, you should use the index of the slice in the loop to get the address of the element as shown below:

 for i := range stus {
    m[stus[i].name] = &stus[i]
}

This method ensures that the address of each student structure is independent, thus avoiding the problem that all values ​​point to the same memory address.

Summarize:

This problem reveals the characteristics of the Go language for...range loop and the behavior of reference types. Understanding the life cycle of temporary variables in for...range loop, and how to properly handle reference types are essential for writing efficient and error-free Go code. Properly using indexes to access slice elements can avoid such memory management traps.

The above is the detailed content of Why do all values ​​in the map point to the same memory address when using for range loop to loop through slices in Go?. For more information, please follow other related articles on the PHP Chinese website!