GO—结构体简述

目录

1，定义结构体

2，访问结构体成员

3，结构体作为函数参数

4，结构体指针

---

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

结构体表示一项记录，比如班级的学生信息，每个人有以下属性:

●Name:姓名 ●Sex:性别 ●Age:年龄 ●IDcard: 身份证

注：结构体是值类型

1，定义结构体

结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

实例如下：

package main
​
import "fmt"
​
//定义结构体
func main() {
    //声明结构体
    type Person struct {
        name string
        sex  string
        age  int
        id   int
    }
    //按顺序进行初始化
    // 创建一个新的结构体
    fmt.Println("顺序初始化结构体：", Person{"张三", "男", 20, 123456789})
    // 也可以使用 key => value 格式初始化
    fmt.Println("按键值类型赋值结构体", Person{name: "李四", sex: "女", age: 25, id: 456123789})
    // 忽略的字段为 0 或 空部分属性赋值初始化
    fmt.Println("部分属性赋值结构体", Person{name: "王五"})
}
[Running] go run "f:\goProject\src\dev_code\day12\example2\main\main.go"
顺序初始化结构体： {张三 男 20 123456789}
按键值类型赋值结构体 {李四 女 25 456123789}
部分属性赋值结构体 {王五  0 0}
​
[Done] exited with code=0 in 0.541 seconds

2，访问结构体成员

如果要访问结构体成员，需要使用点号 . 操作符，格式为：

结构体.成员名"

结构体类型变量使用 struct 关键字定义，实例如下：

package main
​
import "fmt"
​
//定义结构体
func main() {
    //声明结构体
    type Person struct {
        name string
        sex  string
        age  int
        id   int
    }
    //结构体类型的变量
    var Person1 Person
    var Person2 Person
    //给person1赋值
    Person1.name = "张三"
    Person1.sex = "男"
    Person1.age = 20
    Person1.id = 123456
    //给person2赋值
    Person2.name = "李三"
    Person2.sex = "女"
    Person2.age = 22
    Person2.id = 456789
    //输出结构体信息
    fmt.Println(Person1)
    fmt.Println(Person2)
}
[Running] go run "f:\goProject\src\dev_code\day12\example3\main\main.go"
{张三 男 20 123456}
{李三 女 22 456789}
​
[Done] exited with code=0 in 0.452 seconds

3，结构体作为函数参数

你可以像其他数据类型一样将结构体类型作为参数传递给函数。并以以上实例的方式访问结构体变量：

示例：

package main
​
import "fmt"
​
//定义结构体
//声明结构体
type Person struct {
    name string
    sex  string
    age  int
    id   int
}
​
func main() {
    //结构体类型的变量
    var Person1 Person
    var Person2 Person
    //给person1赋值
    Person1.name = "张三"
    Person1.sex = "男"
    Person1.age = 20
    Person1.id = 123456
    //给person2赋值
    Person2.name = "李三"
    Person2.sex = "女"
    Person2.age = 22
    Person2.id = 456789
    //使用函数传参结构体类型数据
    PrintInfo(Person1)
    PrintInfo(Person2)
}
​
//函数定义结构体为形式参数进行传入
func PrintInfo(per Person) {
    fmt.Println("姓名：", per.name)
    fmt.Println("性别：", per.sex)
    fmt.Println("年龄：", per.age)
    fmt.Println("id号:", per.id)
}

以上实例执行运行结果为：

姓名： 张三
性别： 男
年龄： 20
id号: 123456
姓名： 李三
性别： 女
年龄： 22
id号: 456789

4，结构体指针

你可以定义指向结构体的指针类似于其他指针变量，格式如下：

var struct_pointer *Person

以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：

struct_pointer = &Person1

使用结构体指针访问结构体成员，使用 "." 操作符：

struct_pointer.title

接下来让我们使用结构体指针重写以上实例，代码如下：

package main
​
import "fmt"
​
//定义结构体
//声明结构体
type Person struct {
    name string
    sex  string
    age  int
    id   int
}
​
func main() {
    //结构体类型的变量
    var Person1 Person
    var Person2 Person
    //给person1赋值
    Person1.name = "张三"
    Person1.sex = "男"
    Person1.age = 20
    Person1.id = 123456
    //给person2赋值
    Person2.name = "李三"
    Person2.sex = "女"
    Person2.age = 22
    Person2.id = 456789
    //使用函数传参结构体类型数据
    PrintInfo(&Person1)
    fmt.Println()
    PrintInfo(&Person2)
}
​
//函数定义结构体为形式参数进行传入
func PrintInfo(per *Person) {
    fmt.Println("姓名：", per.name)
    fmt.Println("性别：", per.sex)
    fmt.Println("年龄：", per.age)
    fmt.Println("id号:", per.id)
}

以上实例执行运行结果为：

姓名： 张三
性别： 男
年龄： 20
id号: 123456
​
姓名： 李三
性别： 女
年龄： 22
id号: 456789

示例：

package main
​
import "fmt"
​
//定义结构体
//声明结构体
type Person struct {
    name string
    sex  string
    age  int
    id   int
}
​
func main() {
    //结构体类型的变量
    var Person1 Person
    //给person1赋值
    Person1.name = "张三"
    Person1.sex = "男"
    Person1.age = 20
    Person1.id = 123456
    fmt.Println("处理前", Person1)
    PrintInfo(Person1)
    fmt.Println("处理后", Person1)
}
​
//函数定义结构体为形式参数进行传入
func PrintInfo(per Person) {
    per.name = "张四"
}
[Running] go run "f:\goProject\src\dev_code\day12\example5\main\main.go"
处理前 {张三 男 20 123456}  //结构体是值类型
处理后 {张三 男 20 123456}
​
[Done] exited with code=0 in 0.453 seconds
​
//使用指针传数值
package main
​
import "fmt"
​
//定义结构体
//声明结构体
type Person struct {
    name string
    sex  string
    age  int
    id   int
}
​
func main() {
    //结构体类型的变量
    var Person1 Person
    //给person1赋值
    Person1.name = "张三"
    Person1.sex = "男"
    Person1.age = 20
    Person1.id = 123456
    fmt.Println("处理前", Person1)
    PrintInfo(&Person1)
    fmt.Println("处理后", Person1)
}
​
//函数定义结构体为形式参数进行传入
func PrintInfo(per *Person) {
    per.name = "张四"
}
[Running] go run "f:\goProject\src\dev_code\day12\example5\main\main.go"
处理前 {张三 男 20 123456}   //结构体指针是引用类型
处理后 {张四 男 20 123456}  
​
[Done] exited with code=0 in 0.444 seconds

示例：

package main
​
import "fmt"
​
type jiaose struct {
    name   string
    gongji int
}
​
func main() {
    var jiaose1 jiaose
    jiaose1.name = "魔神"
    jiaose1.gongji = 20000
    fmt.Println(jiaose1)
    test(&jiaose1)
    fmt.Println(jiaose1)
}
​
func test(js *jiaose) {
    js.name = "剑神"
    js.gongji = 30000
}
[Running] go run "f:\goProject\src\dev_code\day12\example5\main\main.go"
{魔神 20000}
{剑神 30000}
​
[Done] exited with code=0 in 0.439 seconds