Unexpected result when removing an element from a slice

I encountered unexpected results when I remove the first element from slice, this is my test code, hope to help you understand my confuse
define structure

type A struct {
	member int
}

func (a A) String() string {
	return fmt.Sprintf("%v", a.member)
}

type B struct {
	a      A
	aPoint *A
}

func (b B) String() string {
	return fmt.Sprintf("a: %v, aPoint: %v", b.a, b.aPoint)
}

below is my test case

func TestSliceRemoveFirstEle(t *testing.T) {
	demo := []B{
		{a: A{member: 1}},
		{a: A{member: 2}},
		{a: A{member: 3}},
	}

	for i := range demo {
		demo[i].aPoint = &demo[i].a
	}

	fmt.Println("demo before operation is ", demo) // result: demo before operation is  [a: 1, aPoint: 1 a: 2, aPoint:2 a: 3, aPoint: 3]
	demo = append(demo[:0], demo[1:]...)
	fmt.Println("demo after operation is ", demo) // result: demo after operation is  [a: 2, aPoint: 3 a: 3, aPoint: 3]
}

my expected result is [a: 2, aPoint: 2 a: 3, aPoint: 3]

when I use another way adding element to the slice, it work well.

func TestAddSliceRemoveFirstEle(t *testing.T) {
	demo := make([]B, 0, 3)
	a1 := A{member: 1}
	a2 := A{member: 2}
	a3 := A{member: 3}
	demo = append(demo, B{a: a1, aPoint: &a1}, B{a: a2, aPoint: &a2}, B{a: a3, aPoint: &a3})

	fmt.Println("demo before operation is ", demo) // result: demo before operation is  [a: 1, aPoint: 1 a: 2, aPoint: 2 a: 3, aPoint: 3]
	demo = append(demo[:0], demo[1:]...)
	fmt.Println("demo after operation is ", demo) // result: demo after operation is  [a: 2, aPoint: 2 a: 3, aPoint: 3]
}

I'm confused about the result, what happened in the first case after removing element from slice, and what's the difference between these two implementations?

Essentially the aPoint pointers still point to the same address, but the values at those addresses changed.

After the append it is demo[0].aPoint == &demo[1].a and not demo[0].aPoint == &demo[0].a.

https://play.golang.org/p/HoNhFlxTEFN

The slice expression demo[:0] will result in a new slice of length 0 that points to the same underlying array as the demo slice. The elements stored in that array are still there, they are not discarded.

So after demo[:0] the underlying array is still:

[
    B{a:1,<pointer_to_idx:0_field_a>},
    B{a:2,<pointer_to_idx:1_field_a>},
    B{a:3,<pointer_to_idx:2_field_a>},
]

demo[1:]... drops the first element and passes the remaining two elements to append. Then append takes those two elements and updates the underlying array's first two elements. After that the underlying array will look like this:

[
    B{a:2,<pointer_to_idx:1_field_a>},
    B{a:3,<pointer_to_idx:2_field_a>},
    B{a:3,<pointer_to_idx:2_field_a>},
]

Notice that now, the aPointer field of the 0th element of the array points to the 1st element's a field. And the aPointer field of the 1st element points to the 2nd element's a field.

In your first example all the A structs exist only in the slice and the pointer points to elements of the slice.
In your second example, the A structs exist outside the slice and so there are no pointers against the elements of the slice.

As per the golang append specification at https://golang.org/ref/spec#Appending_and_copying_slices

> If the capacity of s is not large enough to fit the additional values, append allocates a new, sufficiently large underlying array that fits both the existing slice elements and the additional values. Otherwise, append re-uses the underlying array.

Since we are decreasing the size the underlying array is big enough so we are reusing it.
This is what the underlying array of capacity 3 looks like before and after the reslicing

123 - before
233 - after

What pointed at '2' before is now pointing at '3' as your example shows, a simpler way to see can be through this playground

package main

import (
	"fmt"
)

func main() {
	mySlice := []int{1, 2, 3}
	one := &mySlice[0]
	two := &mySlice[1]
	three := &mySlice[2]
	fmt.Printf("%v-%d\n%v-%d\n%v-%d\n",one,*one,two,*two,three,*three)
	fmt.Printf("%v cap %d\n",mySlice, cap(mySlice))
	mySlice = append(mySlice[:1],mySlice[2:]...)
	fmt.Printf("%v cap %d\n",mySlice, cap(mySlice))
	fmt.Printf("%v-%d\n%v-%d\n%v-%d\n",one,*one,two,*two,three,*three)
}

Where you'll see

0xc0000be000-1
0xc0000be008-2
0xc0000be010-3
[1 2 3] cap 3
[1 3] cap 3
0xc0000be000-1
0xc0000be008-3
0xc0000be010-3

In short, taking pointers out of elements of a slice and reslicing it will always cause these kind of errors.
It could also cause memory leak issues as per the footnote here https://github.com/golang/go/wiki/SliceTricks#delete-without-preserving-order