赋值操作（未使用指针）

  1. package main
  3. import "fmt"
  5. //Animal ..
  6. type Animal struct {
  7.     Name string
  8. }
  10. //Bird ..
  11. type Bird struct {
  12.     Animal Animal
  13.     Legs int
  14. }
  16. //Sparrow ..
  17. type Sparrow struct {
  18.     Bird Bird
  19.     Size string
  20. }
  22. func main() {
  23.     var s Sparrow = Sparrow{
  24.         Bird : Bird{
  25.             Animal: Animal{
  26.                 Name: "小麻雀",
  27.             },
  28.             Legs: 2,
  29.         },
  30.         Size: "small",
  31.     }
  33.     s1 := s
  34.     s1.Bird.Animal.Name = "假麻雀"
  35.     s1.Bird.Legs = 16
  36.     s1.Size = "big"
  38.     b1 := s.Bird
  39.     a1 := s.Bird.Animal
  41.     var b2 Bird = s.Bird
  42.     var a2 Animal = s.Bird.Animal
  44.     b1.Legs = 4
  45.     b2.Legs = 8
  47.     a1.Name = "大小麻雀"
  48.     a2.Name = "小小小小麻雀"
  49.     fmt.Printf("%+v\n", s)
  50.     fmt.Printf("%+v\n", s1)
  51.     fmt.Printf("%+v\n", b1)
  52.     fmt.Printf("%+v\n", b2)
  53.     fmt.Printf("%+v\n", a1)
  54.     fmt.Printf("%+v\n", a2)
  55. }
  56. //结果如下
  57. {Bird:{Animal:{Name:小麻雀} Legs:2} Size:small} //s
  58. {Bird:{Animal:{Name:假麻雀} Legs:16} Size:big} //s1
  59. {Animal:{Name:小麻雀} Legs:4} //b1
  60. {Animal:{Name:小麻雀} Legs:8} //b2
  61. {Name:大小麻雀} //a1
  62. {Name:小小小小麻雀} //a2

说明未使用指针情况下，通过结构体赋值后的结构体，改变对原来没有影响

赋值操作（指针）

  1. func main() {
  2.     var s Sparrow = Sparrow{
  3.         Bird : &Bird{
  4.             Animal: &Animal{
  5.                 Name: "小麻雀",
  6.             },
  7.             Legs: 2,
  8.         },
  9.         Size: "small",
  10.     }
  11.     s1 := s
  12.     s1.Bird.Animal.Name = "假麻雀"
  13.     s1.Bird.Legs = 16
  14.     s1.Size = "big"
  16.     b1 := s.Bird
  17.     a1 := s.Bird.Animal
  19.     var b2 Bird = *s.Bird
  20.     var a2 Animal = *s.Bird.Animal
  22.     b1.Legs = 4
  23.     b2.Legs = 8
  25.     a1.Name = "大小麻雀"
  26.     a2.Name = "小小小小麻雀"
  27.     fmt.Printf("%+v,  %p\n", s, s.Bird)
  28.     fmt.Printf("%+v, %p\n", s1, s.Bird)
  29.     fmt.Printf("%+v, %p\n", *b1, b1)
  30.     fmt.Printf("%+v, %p\n", b2, &b2)
  31.     fmt.Printf("%+v, %p\n", *a1, a1)
  32.     fmt.Printf("%+v, %p\n", a2, &a2)
  33. }
  35. //Animal ..
  36. type Animal struct {
  37.     Name string
  38. }
  40. //Bird ..
  41. type Bird struct {
  42.     Animal *Animal
  43.     Legs int
  44. }
  46. //Sparrow ..
  47. type Sparrow struct {
  48.     Bird *Bird
  49.     Size string
  50. }
  51. //结果
  52. {Bird:0xc0000381f0 Size:small},  0xc0000381f0 //s
  53. {Bird:0xc0000381f0 Size:big}, 0xc0000381f0 //s1
  54. {Animal:0xc000038200 Legs:4}, 0xc0000381f0 //b1
  55. {Animal:0xc000038200 Legs:8}, 0xc000038210 //b2
  56. {Name:大小麻雀}, 0xc000038200 //a1
  57. {Name:小小小小麻雀}, 0xc000038220 // a2

可以看出a1地址在b1的指针中， b1地址在s和s1的指针中，因此指针的情况下不能直接复制
不过可以看a2和b2地址和a1，b1地址