Why Does Appending Pointers in a Go `for...range` Loop Produce Unexpected Results?

Understanding Strange Behavior with append in Go

In Go, the append function operates on slices to add new elements. However, users may encounter unexpected behavior when appending pointers to elements from an array within a for range loop.

Consider the following example:

import "fmt"

type Foo struct {
    val int
}

func main() {
    var a = make([]*Foo, 1)
    a[0] = &Foo{0}

    var b = [3]Foo{Foo{1}, Foo{2}, Foo{3}}
    for _, e := range b {
        a = append(a, &e)
    }

    for _, e := range a {
        fmt.Printf("%v ", *e)
    }
}

Expected Output: {0} {1} {2} {3}

Actual Output: {0} {3} {3} {3}

Reason for the Behavior

This unexpected behavior arises because the for range loop iterates over a copy of the elements, not the original elements themselves. In this case, the loop variable e holds a copy of the current element of the array. When the slice is appended, the address of the loop variable is added, which refers to the same memory location for all iterations. Consequently, when the last element of the array is encountered, all appended addresses point to the same element.

Fix

To resolve this issue, the append function should be used with the address of the original array element, not the loop variable. Here is the corrected code:

for i := range b {
    a = append(a, &b[i])
}

With this modification, the output will be as expected: {0} {1} {2} {3}.

Conclusion

Understanding the difference between pointers and non-pointer types in Go is crucial for proper handling of memory references. When using for range loops, it's essential to consider whether you need to access the original element or a copy, and use the appropriate syntax accordingly.

The above is the detailed content of Why Does Appending Pointers in a Go `for...range` Loop Produce Unexpected Results?. For more information, please follow other related articles on the PHP Chinese website!