Go笔记-结构体

结构体简介

　　Go 通过类型别名（alias types）和结构体的形式支持用户自定义类型，或者叫定制类型。一个带属性的结构体试图表示一个现实世界中的实体。结构体是复合类型（composite types），当需要定义一个类型，它由一系列属性组成，每个属性都有自己的类型和值的时候，就应该使用结构体，它把数据聚集在一起。然后可以访问这些数据，就好像它是一个独立实体的一部分。结构体也是值类型，因此可以通过 new 函数来创建。

　　组成结构体类型的那些数据称为字段（fields）。每个字段都有一个类型和一个名字；在一个结构体中，字段名字必须是唯一的。

　　Go中没有类的概念

结构体定义

如果字段在代码中从来不会用到，那么就可以把它命名为_（单独使用下划线，在Go中表示忽略）
结构体的字段可以事任何类型，也可以是函数或是接口

 type identifier struct{

     field1 type1

     field2 type2

     ...

 }

 // 声明

 var s identifier

 identifier.field1 = value

 identifier.field2 = value

结构体声明

 // 下面三种相同，t为结构体指针

 var t *T  // T是结构体类型

 t = new(T)  // 结构体指针变量t

 var t *T = new(T)

 t := new(T)  // 指针变量t

不使用new的声明方式：var t T 也会给t分配内存，并零化内存，t为类型T而不是指针类型*T

结构体赋值和使用

使用点符号给字段赋值或者获取结构体字段的值，变量不管是结构体类型还是结构体指针类型，都使用点符号来引用结构体的字段

　注意当变量类型是指针结构体时，既可以通过指针给结构体字段赋值，也可以通过使用解指针的方式给结构体字段赋值，注意下面的例子

 import "fmt"

 type struct1 {

         i1 int

         f1 float32

         s1 string

     }

 func main(){

    ms := new(struct1) // ms是*struct1类型

    ms.i1 = 10          // 这是通过指针给结构体字段赋值，也可以通过解指针的方式给结构体赋值 这样子(*ms).i1 = 10

    ms.f1 = 1.2

    ms.s1 = "hello,word"

    fmt.Println(ms.i1)

     fmt.Println(ms.f1)

     fmt.Println(ms.s1)

 }

结构体初始化

 // 方式一

 ms:=&struct1{10,1.1,"gao"}  // ms的类型是*struct1

 // 方式二

 var ms struct1

 ms = struct1{10,1.1,"hu"}  // ms的类型是ms

 // 举例

 type Interval struct{

     start int

     end int

 }

 // 以下三种初始化方式

 intr := Interval{0,3}

 intr := Interval{start:3,end:3}

 intt := Interval{end:4}

结构体的内存分布

Go语言中，结构体和它所包含的数据在内存中是以连续块的形式存在的，即使结构体中嵌套有其他的结构体，这在性能上带来了很大的优势。

type Rect1 struct {Min, Max Point}

type Rect2 struct {Min, Max *Point}

【结构体转换】

Go中的类型转换遵循严格的规则。当为结构体定义了一个alias类型时，此结构体类型和它的alias类型都有相同的底层类型。

 package main

 type number struct{

     a int

 }

 type aliasNumber number  // 为结构体number定义了一个alias类型 aliasNumber

Go中实现构造方法

1- 原本不存在构造方法

 type File struct {

     fd int // 文件描述符

     name string // 文件名

 }

 fun newFile(fd int, name,string)*File{

     if fd<0{

         return nil

     }

     return &File{fd,name}

 }

2- 强制用户使用工厂方法：前面提到过，变量小写就会变成私有的，这里的实现也是这个原理。将结构体定义为私有的，在开放一个共有的方法来返回结构的指针。

 type matrix struct{

     //

 }

 func NewMatrix(params)*matrix{

     m := new(matrix)

     return m

 }

 // 在其他包中引入使用

 package main

 import "matrix"

 wrong := new(matrix.matrix)  // wrong way

 right := matrix.NewMatrix(...)  //  right way

带标签的结构体

　　结构体的字段除了有名字和类型外，还可以有一个可选的标签：它是附属于字段的字符串，可以是文档或其他的重要标记。标签的内容不可以在一般的编程中使用，只有反射包reflect能够获取它。

示例如下

 package main

 import "fmt"

 import "reflect"

 type TagType struct{

   f1 bool "an important answer"

   f2 string "the name of the thing"

   f3 int  "how much there are"

 }

 fun main(){

   tt := TagType{true,"kobe",82}

   for i:=0;i<3,i++{

     refTag(tt,i)

   }

 }

 func refTag(tt TagType,ix int){

     ttType := reflect.Typeof(tt)

    ixField := ttType.Field(ix)

    fmt.Printf("%v\n",ixField.Tag)

 }

结构体中的匿名字段

　　结构体中可以包含一个或多个匿名字段（字段没有名字，只有类型，这个类型可以包括结构体类型），但是一个结构体中只能包含一种类型的匿名字段。比如不能同时包含两个int int匿名字段（结构体类型也是同样的道理）。

　　使用带有匿名字段的结构体时，类型名称就是字段名，这就是为什么一个类型只能出现一次了。

package main

import "fmt"

type struct1 struct{

  f1 int

  f2 bool

  f3 string

  float32

  struct2

}

type struct2 struct{

  s1 string

}

func main(){

  s1 := new(struct1)

  s1.f1 = 1

  s1.f2 = true

  s1.f3 = "boom"

  s1.float32 = 2.3

  s1.s1 = "childern"

  fmt.Println(s1)

}

结构体中出现命名冲突

外层名字会覆盖内层名字（但是两者的内存空间都保留），这提供了一种重载字段或方法的方式
如果相同的名字在同一级别出现了两次，如果这个名字被程序使用了，将会引发错误。

　　如果想要使用内层的就通过层层去调用

 package main

 import (

     "fmt"

 )

 type A struct {

     a int

 }

 type B struct {

     a int

     b int

 }

 type C struct {

     A

     B

 }

 func main() {

     var c_struct C

     c_struct.A.a = 10

     c_struct.b = 20

     c_struct.B.a  =30

     fmt.Println(c_struct)

 }

【学习参考处：https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/directory.md】