重温Go语法笔记 | 结构体

• 结构体

  多个任意类型聚合成的复合类型

  1.字段拥有自己的类型和值
  2.字段名必须唯一
  3.字段可以是结构体
  

  结构体的定义是一种内存布局的描述
  只有实例化才会真正分配内存，必须实例化之后才能使用结构体的字段

  • 结构体的实例化

    type Point struct {
      X int
      Y int
    }
    var p Point
    p.X = 10
    p.Y = 20
    

  • 指针类型的结构体

    Go访问结构体指针使用了语法糖，将ins.Name形式转化成(*ins).Name

    type Point struct {
      X int
      Y int
    }
    p := new(Point)
    p.X = 10
    p.Y = 20
    

  • 指针类型的结构体与结构体的区别?

  • 取结构体的地址实例化

    取地址实例化是最广泛的一种结构体实例化方式

    type Person struct {
      Name string
      Age  int
      Sex  int
    }
    
    func main() {
      person := &Person{}
      person.Name = "mkl"
      person.Age = 10
      person.Sex = 1
    }
    

  • 键值对初始化结构体

    type Person struct {
      Name  string
      Age   int
      Sex   int
      child *Person
    }
    
    func main() {
      person := &Person{
        Name: "mkl",
        Age:  20,
        Sex:  1,
        child: &Person{
          Name: "bob",
          Age:  10,
          Sex:  0,
        },
      }
      fmt.Printf("%#v", person)
    }
    

  • 列表初始化结构体

    type Person struct {
      Name  string
      Age   int
      Sex   int
      child *Person
    }
    
    func main() {
      person := &Person{"mkl", 10, 1, &Person{"bob", 11, 0, nil}}
      fmt.Printf("%#v", person)
    }
    

  • 初始化匿名结构体

    func main() {
      person := &struct {
        id   int
        data string
      }{
        id:   1,
        data: "hello",
      }
      fmt.Printf("%#v", person)
    }
    

  • Go方法和接收器

    方法是接收器上的一个函数
    方法的作用对象是接收器，函数没有作用对象

    • 为结构体添加方法

      面向过程

      type Bag struct {
        items []string
      }
      
      func Insert(b *Bag, item string) {
        b.items = append(b.items, item)
      }
      
      func main() {
        bag := Bag{}
        Insert(&bag, "foo")
      }
      

      面向对象

      type Bag struct {
        items []string
      }
      
      func (b *Bag) Insert(item string) {
        b.items = append(b.items, item)
      }
      
      func main() {
        bag := new(Bag)
        bag.Insert("foo")
      }
      

    • 指针接收器

      指针接收器

      type Property struct {
        value int
      }
      
      // 设置属性值
      func (p *Property) Set(v int) {
        p.value = v
      }
      
      // 获取属性值
      func (p *Property) Get() int {
        return p.value
      }
      
      func main() {
        p := new(Property)
        p.Set(10)
        fmt.Println(p.Get())
      }
      

  • 类型内嵌和结构体内嵌

    内嵌的结构体可以直接访问成员变量
    内嵌结构体的字段名是它的类型名

  • 结构体模拟类的继承

    以组合的方式实现继承特性

标签：struct,person,int,重温,语法,Person,func,Go,结构
来源： https://www.cnblogs.com/miaokela/p/16683939.html