概述
在上一节的内容中，我们介绍了Go的函数，包括：函数定义、函数声明、函数调用、可变参数函数、匿名函数、递归函数、高阶函数等。在本节中，我们将介绍Go的结构体。在Go语言中，结构体是一种用户定义的数据类型，它允许你组合不同类型的字段来表示一个复杂的数据结构。结构体可以包含零个或多个字段，每个字段都有一个名称和一个对应的数据类型。
定义结构体
在Go语言中，我们使用type关键字来定义一个结构体类型，并指定结构体的字段及对应的数据类型。以下是定义结构体的基本语法：
type StructName struct {
field1 type1
field2 type2
// …
}
其中，StructName是结构体的名称，field1、field2等是字段的名称，type1、type2等是字段对应的数据类型。
在下面的示例代码中，我们定义了一个名为Person的结构体类型。它包含两个字段：Name和Age，分别表示人的姓名和年龄。
type Person struct {
name string
age int
}声明结构体变量
定义结构体类型后，我们就可以使用该类型声明变量并为其分配内存空间了。在下面的示例代码中，我们声明了一个名为person1的结构体变量，并使用字面量初始化它的各个字段值。如果有字段未赋值，则使用该类型的默认值。
package main
import "fmt"
type Person struct {
name string
age int
}
func main() {
person1 := Person{name: "Mike", age: 18}
// 输出：{Mike 18}
fmt.Println(person1)
person2 := Person{name: "Tom"}
// 输出：{Tom 0}
fmt.Println(person2)
}初始化结构体变量时，也可以不指定键值。此时，会按顺序赋值给结构体的各个字段。
package main
import "fmt"
type Person struct {
name string
age int
}
func main() {
// 不指定键值
person1 := Person{"Mike", 18}
// 输出：{Mike 18}
fmt.Println(person1)
}使用结构体
声明结构体变量后，我们可以使用.运算符来访问和修改结构体变量中的字段。
package main
import "fmt"
type Person struct {
name string
age int
}
func main() {
person1 := Person{name: "Mike", age: 18}
// 输出：name is Mike
fmt.Println("name is", person1.name)
person1.age = 20
// 输出：age is 20
fmt.Println("age is", person1.age)
}结构体也可以在函数中作为参数传递。注意：传入函数中的结构体变量拷贝了一份，并不是原始变量；在函数内部修改结构体字段的值，并不会影响原始变量。在下面的示例代码中，我们在AddPrice()函数中增加了书籍的价格，但main()函数中book结构体变量的price字段仍是原来的100。
package main
import "fmt"
type Book struct {
name string
price int
}
func AddPrice(book Book) {
book.price += 20
}
func main() {
book := Book{name: "Go to Learn Go", price: 100}
// 输出：100
fmt.Println(book.price)
AddPrice(book)
// 输出：100
fmt.Println(book.price)
}如果我们需要AddPrice()函数对价格的修改能够影响原始的book变量，则需要向AddPrice()函数中传入结构体指针。
package main
import "fmt"
type Book struct {
name string
price int
}
func AddPrice(pBook *Book) {
pBook.price += 20
}
func main() {
book := Book{name: "Go to Learn Go", price: 100}
// 输出：100
fmt.Println(book.price)
pBook := &book
AddPrice(pBook)
// 输出：120
fmt.Println(book.price)
}结构体关联函数
在Go语言中，可以通过在结构体上定义函数来实现与结构体关联的函数。这些函数可以访问和操作结构体的字段，以实现特定的功能。要关联函数与结构体，首先需要定义一个函数，函数的接收者类型需指定为该结构体类型。然后，在函数内部，可以直接访问结构体的字段，也可以调用其他与该结构体相关的函数。
package main
import "fmt"
type Book struct {
name string
price int
}
// 结构体关联函数
func (pBook *Book) AddPrice(offset int) {
pBook.price += offset
}
func main() {
book := Book{name: "Go to Learn Go", price: 100}
// 输出：100
fmt.Println(book.price)
pBook := &book
// 关联后，使用结构体变量直接调用函数
pBook.AddPrice(66)
// 输出：166
fmt.Println(book.price)
}Go语言中的结构体没有其他语言中构造器的概念，但我们可以参考下面的示例代码来模拟构造器。
package main
import "fmt"
type Book struct {
name string
price int
}
// 模拟的构造器
func NewBook(name string, price int) *Book {
book := Book{name: name, price: price}
return &book
}
// 结构体关联函数
func (pBook *Book) AddPrice(offset int) {
pBook.price += offset
}
func main() {
pBook := NewBook("Go to Learn Go", 100)
// 输出：100
fmt.Println(pBook.price)
pBook.AddPrice(66)
// 输出：166
fmt.Println(pBook.price)
}new
在Go语言中，new是一个内建函数，用于分配内存并返回指向该内存的指针。它接受一个类型作为参数，并返回一个指向该类型的新分配的零值的指针。new函数的语法如下：
new(T)
其中，T表示要分配的类型。使用new函数可以方便地分配一个新的值，并返回指向该值的指针，这个指针可以被用于进一步初始化该值或访问其成员。
package main
import "fmt"
type Book struct {
name string
price int
}
func main() {
pBook := new(Book)
pBook.name = "Go to Learn Go"
pBook.price = 66
// 输出：Go to Learn Go 66
fmt.Println(pBook.name, pBook.price)
}组合
Go语言并不直接支持传统的基于类的继承和派生，而是采用了组合的方式来实现类似的功能。组合是一种面向对象编程的特性，它允许在一个类型中嵌入另一个类型，从而扩展和组合已有的功能。Go语言中的组合是通过结构体来实现的，可以在结构体中嵌入其他结构体或类型。这种方式允许我们在已有的类型上添加新的功能，而不需要通过继承来共享状态和行为。
在下面的示例代码中，我们定义了一个Base结构体和一个Derived结构体。Derived结构体嵌入了Base结构体，从而可以访问Base的函数和字段。通过在Derived结构体上定义新的函数DerivedFunc，我们为Base类型添加了新的功能。在main函数中，我们创建了一个Derived类型的实例，并分别调用了BaseFunc和DerivedFunc函数。
package main
import "fmt"
// 定义一个基础类型
type Base struct {
name string
number int
}
// 基础类型关联函数
func (b *Base) BaseFunc() {
fmt.Printf("Base func: %s, %dn", b.name, b.number)
}
// 定义一个扩展类型，并嵌入基础类型
type Derived struct {
Base
dataEx int
}
// 扩展类型关联函数
func (d *Derived) DerivedFunc() {
fmt.Printf("Derived func: %s, %d, %dn", d.name, d.number, d.dataEx)
}
func main() {
// 创建扩展类型的实例
derived := &Derived{dataEx: 100}
derived.Base = Base{name: "CSDN", number: 66}
// 调用基础方法，输出: Base func: CSDN, 66
derived.BaseFunc()
// 调用扩展方法，输出: Derived func: CSDN, 66, 100
derived.DerivedFunc()
}