What happens to the pointer to the element when Go moves the slice to another location in memory?

In Go language, when a slice is moved to another location in memory, the pointer to the element changes. Since a slice is a dynamic array, its underlying data structure contains pointers to the array elements as well as the slice's length and capacity information. When a slice is reallocated or expanded, the element pointer it originally pointed to is no longer valid. Therefore, if the previous pointer is still used after the slice is moved, it may cause the wrong memory location to be accessed or other exceptions may be thrown. To avoid this, we should re-obtain the pointer to the element after the slice is moved to ensure the validity and correctness of the pointer. By reacquiring the pointer, we can continue to correctly manipulate and access elements in the slice after the slice is moved.

Question content

I have the following code

package main

import "fmt"

func main() {
    a := []int{1}
    b := &a[0]
    fmt.Println(a, &a[0], b, *b) // prints [1] 0xc00001c030 0xc00001c030 1

    a = append(a, 1, 2, 3)
    fmt.Println(a, &a[0], b, *b) // prints [1 1 2 3] 0xc000100020 0xc00001c030 1
}

First it creates a slice of 1 int. Its len is 1 and its cap is also 1. I then get a pointer to its first element and get the underlying pointer value in print. As expected, it works fine.

I then added 3 elements to the slice, thus extending the slice's capacity, thus copying it to another location in memory. After that, I print the address of the first element of the slice (by getting the pointer), which is now different from the address stored in b.

But when I print the underlying value of b it also works fine. I don't understand why it works. As far as I know, the slice pointed to by the first element b has been copied to another location in memory, so the memory before it must have been freed. However, it still seems to be there.

If we look at the map, golang doesn't even allow us to create pointers on elements by key because of the exact same problem - the underlying data can be moved to another location in memory. However, it works really well for slicing. Why is this so? How exactly does it work? Is the memory not freed because there is still a variable pointing to it? How is it different from a map?

Solution

What happens to the pointer to the element when Go moves the slice to another location in memory?

Nothing at all.

[W]When I print the underlying value of b, it also works fine. I don't understand why it works.

Why doesn't it work?

The memory location originally pointed to still exists and has not changed. As long as anything (e.g. b) still references it, it will still be available. Once all references to that memory are removed (i.e. go out of scope), the garbage collector may allow it to be used by something else.

The above is the detailed content of What happens to the pointer to the element when Go moves the slice to another location in memory?. For more information, please follow other related articles on the PHP Chinese website!