[09]Golang的结构体struct

结构struct

• Go中的struct 与 C 中 的truct非常相似，并且Go没有class
• 使用type< Name >struct{}定义结构，名称遵循可见性规则
• 支持指向自身的指针类型成员
• 支持匿名结构，可用作成员或定义成员变量
• 匿名结构也可用于map的值
• 可以使用字面值对结构进行初始化
• 允许直接通过指针来读写结构成员
• 相同类型的成员可以直接拷贝赋值
• 支持 == 与 != 比较运算符，但不支持 > 或 <
• 支持匿名字段，本质上是定义了某个类型为名称的字段
• 嵌入结构作为匿名字段看起来像继承，但不是继承
• 可以使用匿名字段指针

结构体的定义和使用

type test struct{} //定义结构体

func main() {
	a := test{}
	fmt.Println(a)
}

运行结果：

定义一个Person的结构

type Person struct {
	Name string
	Age  int
} //定义结构体

func main() {
	a := Person{}
	fmt.Println(a)
}

运行结果：

初始化

type Person struct {
	Name string
	Age  int
} //定义结构体

func main() {
	a := Person{}
	a.Name = "jack"
	a.Age = 18
	fmt.Println(a)
}

运行结果：

使用字面值的初始化

type Person struct {
	Name string
	Age  int
} //定义结构体

func main() {
	a := Person{ //字面值初始化
		Name: "jone",
		Age:  19,
	}
	fmt.Println(a)
	A(a) //获得的是值的拷贝
	fmt.Println(a)
}

func A(per Person) { //A(接收一个参数，Person类型)
	per.Age = 13
	fmt.Println("A", per)
}

运行结果：

通过指针可以拷贝地址，改变

type Person struct {
	Name string
	Age  int
} //定义结构体

func main() {
	a := Person{ //字面值初始化
		Name: "jone",
		Age:  19,
	}
	fmt.Println(a)
	A(&a) //获得的是地址
	fmt.Println(a)
}

func A(per *Person) { //A(接收一个参数，Person类型)
	per.Age = 13
	fmt.Println("A", per)
}

运行结果：

可以直接去结构体指针

type Person struct {
	Name string
	Age  int
} //定义结构体

func main() {
	a := &Person{ //a变成指向结构的指针
		Name: "jone",
		Age:  19,
	}
	a.Name = "ok" //可以直接对字段进行操作
	fmt.Println(a)
	A(a)
	B(a)
	fmt.Println(a)
}

func A(per *Person) { //A(接收一个参数，Person类型)
	per.Age = 13
	fmt.Println("A", per)
}

func B(per *Person) { //A(接收一个参数，Person类型)
	per.Age = 15
	fmt.Println("B", per)
}

运行结果：

匿名结构与字段

func main() {
	a := &struct { //临时声明了一个结构， 加&变为一个指针
		Name string
		Age  int
	}{ //进行字面值的初始化
		Name: "John",
		Age:  13,
	}
	fmt.Println(a)
}

运行结果：

匿名结构的嵌套

type person struct {
	Name    string
	Age     int
	Contact struct { //匿名结构
		Phone, City string
	}
}

func main() {
	a := person{Name: "John", Age: 13} //字面值的初始化
	a.Contact.Phone = "1233221"
	a.Contact.City = "wuhan"

	fmt.Println(a)
}

运行结果：

匿名字段

type person struct {
	string
	int
}

func main() {
	a := person{"jno", 16} //初始化时必须严格按照结构体中类型声明的顺序
	fmt.Println(a)
	var b person
	b = a
	fmt.Println(b)
}

运行结果：

type person struct {
	Name string
	Age  int
}

func main() {
	a := person{Name: "John", Age: 19}
	b := person{Name: "John", Age: 19}
	c := person{Name: "John", Age: 18}
	fmt.Println(a == b)
	fmt.Println(a == c)

}

运行结果：

嵌入结构

嵌入结构，在Go中成为组合

type human struct {
	Sex int
}

type teacher struct {
	human
	Name string
	Age  int
}

type student struct {
	human
	Name string
	Age  int
}

func main() {
	a := teacher{Name: "John", Age: 19, human: human{Sex: 0}}
	b := student{Name: "joe", Age: 20, human: human{Sex: 1}}
	fmt.Println(a, b)
	a.Name = "John2"
	a.Age = 13
	a.Sex = 200
	fmt.Println(a, b)
}

运行结果：

结构中的属性和内层嵌套同名的话

type A struct {
	B
	Name string
}
type B struct {
	Name string
}

func main() {
	a := A{Name: "A", B: B{Name: "B"}}
	//a.Name因为A的优先级大于B，所以输出A
	fmt.Println(a.Name, a.B.Name)
}

运行结果：

如果外层结构体中没有该属性的话，会从下层嵌套结果寻找

type A struct {
	B
}
type B struct {
	Name string
}

func main() {
	a := A{B: B{Name: "B"}}
	//如果外层结构体中没有该属性的话，会从下层嵌套结果寻找
	fmt.Println(a.Name, a.B.Name)
}

运行结果：

结构间的赋值与比较

import (
	"fmt"
)

type person struct {
	Name string
	Age  int
}

func main() {
	a := person{Name: "John", Age: 19}
	b := person{Name: "John", Age: 19}
	c := person{Name: "John", Age: 18}
	fmt.Println(a == b)
	fmt.Println(a == c)

}

运行结果：