（7-2）结构体和共用体：结构体成员

7.2  结构体成员

在Go语言中定义了结构体类型以后，就可以使用结构体中的成员。在本节的内容中，将详细讲解使用结构体的知识。

7.2.1  普通变量成员

在Go语言中，可以使用点运算符“.”来访问结构体中的成员变量。例如在下面的实例中有一个名为person的结构体，其中包含名字（name）和年龄（age）字段，则可以使用以下方式访问这些字段。

实例7-1：个税计算器（源码路径：Go-codes\7\fang.go）

实例文件fang.go的具体实现代码如下所示。

type Person struct {
    Name string
    Age int
}
func main() {
    person := Person{Name: "John", Age: 30}
    fmt.Println("Name:", person.Name)
    fmt.Println("Age:", person.Age)
}

在上述代码中，创建了一个名为person的Person结构体实例，并设置了其名称和年龄字段的值。然后通过使用点运算符来访问这些字段并在控制台上打印输出。执行后会输出：

Name: John
Age: 30

7.2.2  数组成员

当结构体成员是数组时，可以使用点运算符和数组下标来访问该数组中的元素。例如下面是一个定义、初始化和访问带有数组成员结构体的例子。

实例7-2：定义、初始化和访问带有数组成员结构体（源码路径：Go-codes\7\arry.go）

实例文件arry.go的具体实现代码如下所示。

type Student struct {
Name   string
Scores [3]int
}

func main() {
student := Student{Name: "John", Scores: [3]int{80, 90, 95}}

fmt.Println("Name:", student.Name)
fmt.Println("Score 1:", student.Scores[0])
fmt.Println("Score 2:", student.Scores[1])
fmt.Println("Score 3:", student.Scores[2])

// Update a score
student.Scores[2] = 100
fmt.Println("New Score 3:", student.Scores[2])
}

在上述代码中，首先定义了一个名为 Student 的结构体，其中包含一个名为 Scores 的数组成员。然后，在 main() 函数中，我们创建一个名为 student 的 Student 类型变量，并设置其姓名（Name）和分数（Scores）字段的值。通过使用点运算符和数组下标，我们可以访问 student 变量中的相应成员变量，例如打印出学生姓名和分数。我们还可以修改学生的分数，例如将第三个分数从 95 改为 100。执行后会输出：

Name: John
Score 1: 80
Score 2: 90
Score 3: 95
New Score 3: 100

7.2.3  指针成员

Go 语言结构体的成员可以是一个指针，当结构体成员是指针时，可以使用点运算符和解引用操作符（*）来访问该指针指向的值。例如在下面的代码中，定义了一个名为 MyStruct 的结构体，其中包含一个名为 MyPointer 的指针成员。该指针的类型是 *int，表示它指向一个整数值。

type MyStruct struct {
    MyPointer *int
}

要想使用这个结构体成员，可以通过如下代码实现。

var s MyStruct
x := 5
s.MyPointer = &x

在上述代码中，首先定义了一个名为 s 的 MyStruct 类型变量。然后，定义了一个名为 x 的整数变量，并将其设置为 5。接着，将成员MyPointer设置为指向 x 变量的地址。

另外，还可以通过解引用指针来访问和修改指向的值，例如下面的代码，将修改 MyPointer 指向的值，将其从 5 改为 42。

*s.MyPointer = 42

需要注意的是，在使用结构体指针时，必须在分配内存和使用指针之间进行区分。如果没有正确分配内存，或者在指针为空时对其进行解引用，则可能会导致程序崩溃或出错。

实例7-3：定义、初始化和访问带有指针成员的结构体（源码路径：Go-codes\7\zhi.go）

实例文件zhi.go的具体实现代码如下所示。

type Person struct {
	Name string
	Age  *int
}
func main() {
	age := 30
	person := Person{Name: "John", Age: &age}

	fmt.Println("Name:", person.Name)
	fmt.Println("Age:", *person.Age)

	// Update the age
	newAge := 35
	person.Age = &newAge
	fmt.Println("New Age:", *person.Age)
}

在上述代码中，首先定义了一个名为 Person 的结构体，其中包含一个名为 Age 的指针成员。然后，在主函数main()中创建了一个名为 person 的 Person 类型变量，并设置其姓名（Name）和年龄（Age）字段的值。通过使用点运算符和解引用操作符（*），我们可以访问指向的年龄值，并打印出相应的输出。我们还可以修改人的年龄，例如将年龄从 30 改为 35。执行后会输出：

Name: John
Age: 30
New Age: 35

注意：在使用结构体指针时，必须在分配内存和使用指针之间进行区分。如果没有正确分配内存，或者在指针为空时对其进行解引用，则可能会导致程序崩溃或出错。

7.2.4  函数成员

在 Go 语言中，结构体成员可以是函数类型。要在结构体中定义函数成员，可以按照以下步骤进行：

1. 定义一个函数类型。
2. 在结构体中将该函数类型作为一个成员变量。
3. 定义一个接收器方法来实现该函数。

实例7-4：定义、初始化和访问带有函数成员的结构体（源码路径：Go-codes\7\han.go）

实例文件han.go的具体实现代码如下所示。

type MyStruct struct {
	MyFunction func(int, int) int
}

func (s *MyStruct) CallMyFunction(x, y int) int {
	return s.MyFunction(x, y)
}

func main() {
	s := MyStruct{
		MyFunction: func(x, y int) int {
			return x + y
		},
	}
	result := s.CallMyFunction(3, 5)
	fmt.Println("Result:", result)
}

对上述代码的具体说明如下：

1. 首先定义了一个名为 MyFunction的函数类型。然后，在结构体中定义了一个名为 MyFunction的函数成员，其类型是 func(int, int) int。这意味着该函数接受两个整数参数，并返回一个整数结果。
2. 接下来，定义了一个名为 CallMyFunction 的接收器方法，它接受一个指向 MyStruct 类型的指针，并使用该指针访问结构体中的 MyFunction 成员。该方法将 x 和 y 参数传递给该函数，并返回函数的结果。
3. 在主函数中，创建了一个名为 s 的 MyStruct 类型变量，并将其 MyFunction 成员设置为一个可以计算加法的匿名函数。然后，我们调用 CallMyFunction 函数来调用该函数，并输出其结果。

执行后会输出：

Result: 8