概述

        在上一节的内容中，我们介绍了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, %d\n", b.name, b.number)
}
  
// 定义一个扩展类型，并嵌入基础类型
type Derived struct {
    Base
    dataEx int
}
// 扩展类型关联函数
func (d *Derived) DerivedFunc() {
    fmt.Printf("Derived func: %s, %d, %d\n", 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()
}