第十四章:Go语言结构体struct

文章目录

• 1. 结构体 struct
• 1.1 概述
• 1.2. 定义结构体
• 1.3 实例化结构体
• 1.4 初始化结构体成员变量
• 1.5 结构体变量复制
• 1.6 匿名结构体
• 1.7 模拟构造函数

1. 结构体 struct

1.1 概述

Go语言可以通过自定义的形式形成新的类型,结构体是类型中带有成员的复合类型,Go语言中使用结构体和结构体成员描述 真实世界 的实体和实体对应的各种属性 ,通过这个描述体现了Go语言中

struct

和

class

具有同等地位

结构体成员

是一系列

成员变量

构成的,这些成员变量也被称为

字段

• 字段拥有自己的类型和值
• 一个结构体中字段名必须是唯一的
• 字段的类型可以是结构体

Go语言中结构体可以拥有

方法

并且每种自定义类型都可以拥有自己的方法

Go语言中没有继承这样的面向对象特性,只保留了

组合

这个基础的特性, 组合是形成复合类型的基础

1.2. 定义结构体

结构体是复合类型,通过

type

定义

结构体的定义格式如下:

type 结构体名称 struct{
字段1 类型
字段2 类型
字段3 类型
...
}

• 结构体名称 : 标识自定义结构体的名称 ,在同一包内不能重复
• struct{} : 标识这是个结构体类型
• 字段: 表示结构体中的字段名,在一个结构体中字段名必须是唯一
• 类型: 表示对应的结构体的数据类型,

package main
//定义一个Color的结构体
type Color struct {
R,G,B byte
}
// 定义一个point 结构体
type Point struct {
x int64
y int64
}
// 定义一个Student的结构体
type Student struct {
name string
age int
course []string
score map[string]int
average float32
graduate bool
}
func main(){

}

1.3 实例化结构体

结构体定义只是一种内存布局的描述,只有当结构体实例化时,才会真正分配内存,因此只有在结构体实例化之后才能使用结构体中的字段

• 实例化结构体也是创建一个结构体变量
• 访问结构体中的成员变量通过

  .

  实现
• 实例化一个结构体,要是没有复,那么结构体变量中访问字段的初始值都是默认值
• 对同一个结构体实例化出来的多个结构体变量,这些变量个各不相干,结构体是对内存布局的描述,每次实例化都是结构体变量分配新的内存

结构体本身是一种类型,所以可以以

var

关键字声明一个变量是结构体的结构体变量,这样就完成了实例化

package main

import "fmt"

type Student struct {
name     string
age      int
course   []string
score    map[string]int
average  float32
graduate bool
}

func main() {
// 实例化方式1
var stu1  Student
fmt.Println(stu1)
}

实例化方法2

package main

import "fmt"

type Student struct {
name     string
age      int
course   []string
score    map[string]int
average  float32
graduate bool
}

func main() {
// 实例化方式2
var stu2 Student = Student{}
fmt.Println(stu2)
}

实例化方法3

Go语言中使用

new

关键字对类型进行实例化,结构体在实例化之后会形成结构体指针

格式:

ins : = new (T)

int *T = new(T)

package main

import "fmt"

type Student struct {
name     string
age      int
course   []string
score    map[string]int
average  float32
graduate bool
}

func main() {
// 实例化方式1
var stu3 *Student = new(Student)
fmt.Println(stu3)
}

go run main.go

&{ 0 [] map[] 0 false}

实例化方法4 ,

格式如下:

int := &T{}

var int * T = &T{}

对结构体进行取地址

&

操作,相当于是进行一次new 的实例化操作 ,得到的是结构体指针

package main

import "fmt"

type Student struct {
name     string
age      int
course   []string
score    map[string]int
average  float32
graduate bool
}

func main() {
// 实例化方法4
var stu4 *Student = &Student{}
fmt.Println(stu4)
}

go run main.go

&{ 0 [] map[] 0 false}

1.4 初始化结构体成员变量

结构体在实例化时,或者之后都可以对其成员变量进行初始化

package main

import "fmt"

type Student struct {
name     string
age      int
course   []string
score    map[string]int
average  float32
graduate bool
}

func main() {
var stu1  Student
// 结构体变量成员初始化1 访问结构体字段方式赋值
stu1.name = "张三"
stu1.age = 70
// slice 和 map 都需要make之后才能使用
stu1.course = make([]string,3)
stu1.course[0] = "数学"
stu1.course[1] = "物理"
stu1.course[2] = "化学"
fmt.Println(stu1)
// 结构体变量成员初始化2 键值对形式赋值
var stu2 Student = Student{
name:"李四",
age:70,
course:[]string{"语文","地理"},
score: map[string]int{"语文":120,"地理":90},
average:105.0,
graduate:false,
}
fmt.Println(stu2)
// 结构体变量成员初始化3 值列表形式赋值
stu3 := Student{
"王五",
70,
[]string{"音乐","美术"},
map[string]int{"音乐":90,"美术":80},
85.0,
true,
}
fmt.Println(stu3)
}

go run main.go

{张三 70 [数学 物理 化学] map[] 0 false}
{李四 70 [语文 地理] map[地理:90 语文:120] 105 false}
{王五 70 [音乐 美术] map[美术:80 音乐:90] 85 true}

看一访问结构体成员的例子

结构体指针访问结构体成员的标准格式是

(*结构体指针).字段名

,例如下面的例子

(*stu).name = "赵六"

但是在go语言中也支持

结构体.字段名

如下

stu.name = "秦七"

的形式,这是因为go语言自己做了一个简化,Go在编译时将

stu.name

转化成了

(*stu).name

package main

import "fmt"

type Student struct {
name     string
age      int
course   []string
score    map[string]int
average  float32
graduate bool
}
func main() {
var stu *Student = new(Student)
fmt.Println(stu)
// 结构体变量stu是结构体指针那么访问结构体成员
(*stu).name = "赵六"
fmt.Println(*stu)
// 一般的方法访问结构体成员变量
stu.name = "秦七" // (*stu).name = "秦七"
fmt.Println(*stu)
}

go run main.go

&{ 0 [] map[] 0 false}{赵六 0 [] map[] 0 false}
{秦七 0 [] map[] 0 false}

1.5 结构体变量复制

结构体变量作为值赋给另外的变量是值拷贝,那么这两个结构体变量没有任何关系

结构体变量也可以将结构体地址赋值给结构体指针变量,这样就成了地址拷贝

package main

import "fmt"

type Person struct {
name string
age  int
}

func main() {
var p1 Person = Person{"张三", 70}
// 结构体值拷贝
p2  := p1
p2.name = "李四"
fmt.Printf("p1 =>addr = %p,value = %v\n", &p1, p1)
fmt.Printf("p2 =>addr = %p,value = %v\n", &p2, p2)
// 结构体地址拷贝
var p3 *Person = &p2
// p3的修改,直接影响p2
p3.name = "王五"
fmt.Printf("p2 =>addr = %p,value = %v\n", &p2, p2)
// p3的值就是p2 的地址,当然p3也有自己的内存地址
fmt.Printf("p3 =>addr = %p,p3 = value = %p\n", &p3, p3)

}

go run main.go

p1 =>addr = 0xc00004a420,value = {张三 70}
p2 =>addr = 0xc00004a440,value = {李四 70}
p2 =>addr = 0xc00004a440,value = {王五 70}
p3 =>addr = 0xc000080020,p3 = value = 0xc00004a440

1.6 匿名结构体

匿名结构体就是没有结构体名称的结构体,无需type关键字就可以直接使用

使用的不多,此处只是提一下

定义格式和初始化写法

ins := struct{
字段名1 类型1
字段名2 类型2
字段名3 类型3
...
}{
字段名1 : 值1,
字段名2 : 值2,
字段值3 : 值3,
...
}

package main

import "fmt"

func getType(ins struct {
id   int
data string
}) {
fmt.Printf("%T\n", ins)
ins.id = 99
fmt.Println(ins)
}
func main() {
ins := struct {
id   int
data string
}{
1,
"hello golang",
}
// 将结构体当做值赋给另外一个变量,值拷贝
ins2 := ins
ins2.id = 2
ins2.data = "hello world"
getType(ins)
getType(ins2)
fmt.Println(ins)
fmt.Printf("%T\n", ins)
}

go run main.go

struct { id int; data string }
{99 hello golang}
struct { id int; data string }
{99 hello world}
{1 hello golang}
struct { id int; data string }

1.7 模拟构造函数

Go语言中没有进行显示初始化的值都会使用它自身的默认值,结构体也是如此.Go语言中没有其他编程语言中的

构造函数

这个概念,那么结构体的初始化工作可以交给一个全局的构建函数函数来完成,模拟出

构造函数

package main

import "fmt"

type Person struct {
name        string
nationality string
BloodType   byte
}

func NewPerson(name string, nationality string, blood byte) *Person {
return &Person{
name:        name,
nationality: nationality,
BloodType:   blood,
}
}
func main() {
p1 := NewPerson("张三", "汉族", 'A')
fmt.Printf("%s 是 %s 血型是%c型\n", p1.name, p1.nationality, p1.BloodType)
p2 := NewPerson("李四", "满族", 'B')
fmt.Printf("%s 是 %s 血型是%c型", p2.name, p2.nationality, p2.BloodType)
}

go run main.go

张三 是 汉族 血型是A型
李四 是 满族 血型是B型

• 点赞
• 收藏
• 分享
• 文章举报

Gcaptain 发布了28 篇原创文章 · 获赞 1 · 访问量 368 私信 关注