Golang

关注公众号 jb51net

关闭
首页 > 脚本专栏 > Golang > Go语言 结构体

深入理解Go语言中的结构体

作者：hope_wisdom

本文主要介绍了深入理解Go语言中的结构体,包括定义结构体、声明结构体变量、使用结构体、结构体关联函数、new、组合等,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

概述

在上一节的内容中，我们介绍了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()
}

到此这篇关于深入理解Go语言中的结构体的文章就介绍到这了,更多相关Go语言 结构体内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文