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】