golang 结构体

1. 定义

结构体是将另个或者多个任意类型的命名变量组合在一起的聚合数据类型。

2. 成员变量

• 访问控制机制
  如果一个结构体的成员变量名称是首字母大些的，那么这个变量是可导出的（即在其他包可以访问到）。
  一个结构体可以同时包含可导出和不可导出的成员变量

type A struct {
    Hour int    //可导出
    minute int  //不可导出
}

• 限制
  命名结构体类型s不可以定义一个拥有相同结构体类型s的成员变量，也就是一个聚合类型不可以包含它自己。但是s中可以定义一个s的指针类型，即*s。如下：

type B struct {
    value int
    //Next B   //错误
    Next *B    //正确
}

3. 结构体比较

1. 如果结构体的所有成员变量都可以比较，那么这个结构体是可以比较的。两个结构体的比较可以使用==或者!=。

type C struct {
    A int
    B string
}
c1 := C{A:1, B:"abc"}
c2 := C{A:1, B:"abc"}
c3 := C{A:2, B:"abc"}
fmt.Println(c1.A == c2.A && c1.B == c2.B) //true
fmt.Println(c1 == c2)                        //true 与上等价
fmt.Println(c1.A == c3.A && c1.B == c3.B) //false
fmt.Println(c1 == c3)                        //false 与上等价

2.和其他可比较的类型一样，可比较的结构体类型都可以作为map的键类型。

type C struct {
    A int
    B string
}
mp := make(map[C]int)
key := C{A:1, B:"abc"}
mp[key] = 9
fmt.Println(mp[C{A:1, B:"abc"}])  //9

4. 结构体嵌套和匿名成员

1. go允许我们定义不带名称的结构体成员，只需要指定类型即可；这种结构体成员称作匿名成员。这个结构体成员的类型必须是一个命名类型或者指向命名类型的指针。正是因为有了这种结构体嵌套的功能，我们才能直接访问到我们需要的变量而不是指定一大串中间变量。

type Point struct {
    X int
    Y int
}
type Circle struct {
    Point
}
var c Circle
c.X = 10  //等价于 c.Point.X = 10
c.Y = 10  //等价于 c.Point.Y = 10

type Wheel struct {
    *Point
}

2. 结构体字面量初始化没有快捷方式，必须遵循形状类型的定义。

type Point struct {
    X int
    Y int
}
type Circle struct {
    Point
}
var c Circle
c = Circle{1,1}  //错误
c = Circle{Point{1,1}}  //正确
c = Circle{Point: Point{1,1}}  //正确

3.因为“匿名成员”拥有隐式的名字，所以你不能在一个结构体里面定义两个相同类型的匿名成员，否则会引起冲突。由于匿名成员的名字是由它们的类型决定的，因此它们的可导出性也是由他们的的类型决定。在下面的例子中，point和circle这两个匿名成员是可导出的，即使这两个结构体是不可导出的（point和circle）。

type point struct {
    X int
    Y int
}
type circle struct {
    point
}

type Wheel struct {
    circle
}
var w Wheel
w.X = 8 // 等价于 w.circle.point.X = 8, w.X是可导出的，w.circle.point.X是不可导出的