类型定义和类型别名的区别

类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别。

  1. //类型定义
  2. type NewInt int
  3. //类型别名
  4. type MyInt = int
  5. func main() {
  6.     var a NewInt
  7.     var b MyInt
  8.     fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
  9.     fmt.Printf("type of b:%T\n", b) //type of b:int
  10. }

结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型。b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。

构造函数

Go语言的结构体没有构造函数，可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。

  1. func newPerson(name, city string, age int8) *person {
  2.     return &person{
  3.         name: name,
  4.         city: city,
  5.         age:  age,
  6.     }
  7. }

匿名结构体

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。

  1. var apr = struct {
  2.         Name string
  3.         Age  int
  4.     }{
  5.         Name: "zhangsan",
  6.         Age: 13,
  7.     }

go中的结构体内存布局和c结构体布局类似，每个成员的内存分布是连续的，在以下示例中通过反射进行进一步说明：

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. type Student struct {
  9.     Name  string
  10.     Age   int64
  11.     wight int64
  12.     high  int64
  13.     score int64
  14. }
  16. func main() {
  17.     var stu1 = new(Student)
  18.     fmt.Printf("%p\n", &stu1.Name)
  19.     fmt.Printf("%p\n", &stu1.Age)
  20.     fmt.Printf("%p\n", &stu1.wight)
  21.     fmt.Printf("%p\n", &stu1.high)
  22.     fmt.Printf("%p\n", &stu1.score)
  23.     typ := reflect.TypeOf(Student{})
  24.     fmt.Printf("Struct is %d bytes long\n", typ.Size())
  25.     // We can run through the fields in the structure in order
  26.     n := typ.NumField()
  27.     for i := 0; i < n; i++ {
  28.         field := typ.Field(i)
  29.         fmt.Printf("%s at offset %v, size=%d, align=%d\n",
  30.             field.Name, field.Offset, field.Type.Size(),
  31.             field.Type.Align())
  32.     }
  33. }
  36. // result
  37. 0xc000098180
  38. 0xc000098190
  39. 0xc000098198
  40. 0xc0000981a0
  41. 0xc0000981a8
  42. Struct is 48 bytes long
  43. Name at offset 0, size=16, align=8
  44. Age at offset 16, size=8, align=8
  45. wight at offset 24, size=8, align=8
  46. high at offset 32, size=8, align=8
  47. score at offset 40, size=8, align=8

可以看到内存地址的偏移总是以8字节偏移（使用的是int64，刚好是8字节），在观察其内存地址，也是连续的，所以go语言中的结构体内存布局是连续的。如下图：

image.png

因为空结构体是不占用内存的，所以size为0，在内存分配时，size为0会统一返回zerobase的地址，所以空结构体在进行参数传递时，发生值拷贝后地址都是一样的，才造成了这个质疑Go不是值传递的假象。

所以在判断是否存在的时候可以 map[type]struct{}

空结构体在结构体中的前面和中间时，是不占用空间的，但是当空结构体放到结构体中的最后时，会进行特殊填充，struct { } 作为最后一个字段，会被填充对齐到前一个字段的大小，地址偏移对齐规则不变；

  1. 空结构体也是一个结构体，不过他的size为0，所有的空结构体内存分配都是同一个地址，都是zerobase的地址；
  2. 空结构体作为内嵌字段时要注意放置的顺序，当作为最后一个字段时会进行特殊填充，会被填充对齐到前一个字段的大小，地址偏移对齐规则不变；