关于golang struct 中的 slice 无法原子赋值的问题

type MySt struct{
    Field []byte
}

func Swap(arr []MySt, i,j int){
    arr[i], arr[j] = arr[j], arr[i]
}

func Swap(arr []MySt, i,j int){
    arr[i].Field, arr[j].Field = arr[j].Field, arr[i].Field
}

func Swap(arr []MySt, i,j int){
    arr[i].Field, arr[j].Field = swapSlice(arr[j].Field, arr[i].Field)
}
func swapSlice(a, b []byte) ([]byte, []byte) {
	return b, a
}

type Person struct {
	Name  string
	Age   int
	Score [5]float64
	ptr   *int
	slice []int
	map1  map[string]string
}
func main() {
	var p1 Person
	fmt.Println(p1)
    fmt.Println()
	if p1.ptr == nil {
		fmt.Println("ok1")
	}
	if p1.slice == nil {
		fmt.Println("ok2")
	}
	if p1.map1 == nil {
		fmt.Println("ok3")
	}
	//使用 slice 一定要先make
	p1.slice = make([]int, 10)
	p1.slice[0] = 100
	p1.map1 = make(map[string]string)
	p1.map1["key1"] = "tom"
	fmt.Println(p1)
}

type Monster struct {
	Name string
	Age  int
}
func main() {
	var monster1 Monster
	monster1.Name = "牛博文"
	monster1.Age = 500
	monster2 := monster1
	monster2.Name = "芜湖"
	fmt.Println("monster1 = ", monster1)
	fmt.Println("monster2 = ", monster2)
}

monster2 := &monster1
	monster2.Name = "芜湖"
	fmt.Println("monster1 = ", monster1)
	fmt.Println("monster2 = ", *monster2)

r1 := Rect{Point{1, 2}, Point{3, 4}}
	fmt.Println(r1)
	//r1有四个int，在内存中是连续分布的
	//打印地址
	fmt.Printf("r1.leftUp.x的地址是 %p\n", &r1.leftUp.x)
	fmt.Printf("r1.leftUp.y的地址是 %p\n", &r1.leftUp.y)
	fmt.Printf("r1.righttUp.x的地址是 %p\n", &r1.rightUp.x)
	fmt.Printf("r1.rightUp.y的地址是 %p\n", &r1.rightUp.y)
	fmt.Println()
	//r2有两个 *Point类型，这两个*Point类型的本身地址是连续的，但是他们指向的地址不一定是连续的
	r2 := Rect2{&Point{10, 20}, &Point{30, 40}}
	//打印地址
	fmt.Printf("r2.leftUp 本身的地址是%p\n", &r2.leftUp)
	fmt.Printf("r2.rightUp 本身的地址是%p\n", &r2.rightUp)
	fmt.Printf("r2.leftUp 指向的地址是%p\n", r2.leftUp) 
	fmt.Printf("r2.rightUp 指向的地址是%p\n", r2.rightUp)
	fmt.Printf("r2.leftUp.x的地址是 %p\n", &r2.leftUp.x)
	fmt.Printf("r2.leftUp.y的地址是 %p\n", &r2.leftUp.y)
	fmt.Printf("r2.righttUp.x的地址是 %p\n", &r2.rightUp.x)
	fmt.Printf("r2.rightUp.y的地址是 %p\n", &r2.rightUp.y)

type A struct {
	num int
	str string
}
type B struct {
	num int
	str string
}
func main() {
	var a A
	var b B
	a = A(b)
	fmt.Println(a, b)
}     //输出结果为 {0 } {0 }

type Student struct {
	Name string
	Age  int
}
type Stu Student
func main() {
	var stu1 Student
	var stu2 Stu
	// stu2 = stu1    这样会报错，因为golang认为Stu是重新定义的结构体
	stu1 = Student(stu2)
	fmt.Println(stu1, stu2)
}    //输出结果为：{ 0} { 0}

type Monsters struct {
	Name  string `json:"name"`   //`json:"name"`就是struct tag
	Age   int    `json:"age"`
	Skill string `json:"skill"`
}
func main() {
	//1. 创建一个monster变量
	monster := Monsters{"牛魔王", 500, "芭蕉扇"}
	//2. 将monster变量序列化为 json格式字串
    //  json.Marshal函数中使用了反射
	jsonMonster, err := json.Marshal(monster)
	if err != nil {
		fmt.Println("json 处理错误", err)
	}
	//如果age, name, skill首字母是小写，name返回空序列，所以必须要大写
	//但如果某些程序员或用户不习惯大写，非要小些，那么可以在struct定义的时候加上 `json:"name"`
	//注意：式键盘左上角的``,不是引号''
	fmt.Println("jsonMonster", jsonMonster)
	fmt.Println("jsonMonster", string(jsonMonster))
}

type Person struct {
	Name string
	Age  int
}
func main() {
	p1 := Person{}
	p1.Name = "tom"
	p1.Age = 18
	fmt.Println(p1)     //{tom 18}
}

p2 := Person{"marry", 18}
	fmt.Println(p2)    //{marry 18}

// var person *person = new (Person)
	var p3 *Person = new(Person)
	//因为p3是一个指针，因此标准的给字段赋值
	(*p3).Name = "smith"
	//(*p3).Name = "smith" 也可以这样写 p3.Name = "smith"
	//原因：go的设计者为了程序员使用方便，底层会对p3.Name = "smith"进行处理
	//会给 p3 加上取值运算(*p3).Name = "smith"
	p3.Name = "amy"
	(*p3).Age = 30
	fmt.Println(*p3)   //{amy 30}

// var person *Person = &person{}
	var person *Person = &Person{}
	//因为person是一个指针，因此标准的访问字段的方法
	//(*person).Name = "scott"
	//go的设计者为了程序员使用方便，也可以person.Name = "scott"
	//原因和上面一样，底层会对 person.Name = "scott"进行处理，会加上(*person)
	(*person).Name = "scott"
	person.Name = "scott~~"
	(*person).Age = 88
	person.Age = 10
	fmt.Println(*person)