31、Go 结构体 - 结构体的相关使用
hi，我是温新
结构体是值类型
结构体若作为参数传递到函数中，在函数中对参数进行修改不会影响到实际参数。
package main
import "fmt"
func main() {
h1 := Human{"王美丽", 20, 1}
fmt.Printf("%T, %v, %p\n", h1, h1, &h1)
// 赋值结构体
h2 := h1
h2.name = "二哈"
fmt.Printf("h2修改后：%T, %v, %p\n", h2, h2, &h2)
// 结构体作为参数传递
changeName(h1)
fmt.Printf("%T, %v, %p\n", h1, h1, &h1)
}
type Human struct {
name string
age int8
sex byte
}
func changeName(h Human) {
h.name = "王小丽"
fmt.Printf("在函数中修改后：%T, %v, %p\n", h, h, &h)
}
输出结果
main.Human, {王美丽 20 1}, 0xc000008078
h2修改后：main.Human, {二哈 20 1}, 0xc0000080c0
在函数中修改后：main.Human, {王小丽 20 1}, 0xc000008108
main.Human, {王美丽 20 1}, 0xc000008078
从结果中可以看到，修改 h2 对 h1 没有影响，把 h1 作为参数传递给函数然后进行修改，依旧没有对 h1 造成影响。
结构体的深拷贝与浅拷贝
值类型是深拷贝，深拷贝就是为新的对象分配了内存。引用类型是浅拷贝，浅拷贝只是复制了对象的指针。
package main
import "fmt"
func main() {
// 结构体深拷贝
dog1 := Dog{"二哈", "棕色", 2}
fmt.Printf("dog1：%T, %v, %p\n", dog1, dog1, &dog1)
// 1、深拷贝
dog2 := dog1
fmt.Printf("dog2：%T, %v, %p\n", dog2, dog2, &dog2)
dog2.name = "中华田园犬-小花"
fmt.Println("dog2 修改后：", dog2)
fmt.Println("dog1：", dog1)
fmt.Println("------------------")
// 2、结构体浅拷贝，复制指针地址
dog3 := &dog1
fmt.Printf("dog3：%T, %v, %p\n", dog3, dog3, dog3)
dog3.name = "边牧"
dog3.color = "黑色"
fmt.Println("dog3修改后：", dog3)
fmt.Println("dog1：", dog1)
fmt.Println("------------------")
// 3、结构体浅拷贝，new 函数
dog4 := new(Dog)
dog4.name = "拉布拉多"
dog5 := dog4
fmt.Printf("dog4：%T, %v, %p\n", dog4, dog4, dog4)
fmt.Printf("dog5：%T, %v, %p\n", dog5, dog5, dog5)
fmt.Println("------------------")
dog5.color = "黄色"
fmt.Println("dog5 修改后：", dog5)
fmt.Println("dog4：", dog4)
}
type Dog struct {
name, color string
age int8
}
输出结果
dog1：main.Dog, {二哈 棕色 2}, 0xc000114510
dog2：main.Dog, {二哈 棕色 2}, 0xc0001145a0
dog2 修改后： {中华田园犬-小花 棕色 2}
dog1： {二哈 棕色 2}
------------------
dog3：*main.Dog, &{二哈 棕色 2}, 0xc000114510
dog3修改后： &{边牧 黑色 2}
dog1： {边牧 黑色 2}
------------------
dog4：*main.Dog, &{拉布拉多 0}, 0xc000114720
dog5：*main.Dog, &{拉布拉多 0}, 0xc000114720
------------------
dog5 修改后： &{拉布拉多 黄色 0}
dog4： &{拉布拉多 黄色 0}
结构体作为函数的参数及返回值
结构体作为函数的参数及返回值有两种形式：值传递和引用传递。
package main
import "fmt"
func main() {
/**
* 1、结构体作为参数的用法
*/
f1 := Flower{"水仙花", "白色"}
fmt.Printf("f1：%T,%v,%p\n", f1, f1, &f1)
fmt.Println("-----------------------")
// 结构体对象作为函数参数
changeInfo1(f1)
fmt.Printf("f1：%T,%v,%p\n", f1, f1, &f1)
// 结构体指针作为函数参数
changeInfo2(&f1)
fmt.Printf("f1：%T,%v,%p\n", f1, f1, &f1)
fmt.Println("-----------------------")
/**
* 结构体作为返回值的用法
*/
// 结构体对象作为返回值
f2 := getFlower1()
f3 := getFlower1()
fmt.Println("修改前：", f2, f3)
fmt.Printf("f2地址为 %p,f3 地址为%p\n", &f2, &f3) // 地址发生变化，对象发生了复制
f2.name = "杏花"
fmt.Println("修改后：", f2, f3)
fmt.Println("-----------------------")
// 结构体作为指针返回值
f4 := getFlower2()
f5 := getFlower2()
fmt.Println("修改前：", f4, f5)
f4.name = "樱花"
fmt.Println("修改后：", f4, f5)
}
type Flower struct {
name, color string
}
// 返回结构体对象
func getFlower1() (f Flower) {
f = Flower{"菊花", "黄色"}
fmt.Printf("函数 getFlower1 内 f：%T, %v, %p\n", f, f, &f)
return
}
// 返回结构体指针
func getFlower2() (f *Flower) {
temp := Flower{"玫瑰", "红色"}
fmt.Printf("函数 getFlower2 内 temp：%T, %v, %p\n", temp, temp, &temp)
f = &temp
fmt.Printf("函数 getFlower2 内 f：%T, %v, %p\n", f, f, &f)
return
}
// 传递结构对对象
func changeInfo1(f Flower) {
f.name = "月季"
f.color = "粉色"
fmt.Printf("函数 changeInfo1 内 f：%T, %v, %p\n", f, f, &f)
}
// 传递结构体指针
func changeInfo2(f *Flower) {
f.name = "蔷薇"
f.color = "紫色"
fmt.Printf("函数 changeInfo2 内 f：%T, %v, %p, %p\n", f, f, f, &f)
}
输出结果
f1：main.Flower,{水仙花 白色},0xc0000603c0
-----------------------
函数 changeInfo1 内 f：main.Flower, {月季 粉色}, 0xc000060440
f1：main.Flower,{水仙花 白色},0xc0000603c0
函数 changeInfo2 内 f：*main.Flower, &{蔷薇 紫色}, 0xc0000603c0, 0xc00000a030
f1：main.Flower,{蔷薇 紫色},0xc0000603c0
-----------------------
函数 getFlower1 内 f：main.Flower, {菊花 黄色}, 0xc000060560
函数 getFlower1 内 f：main.Flower, {菊花 黄色}, 0xc0000605e0
修改前： {菊花 黄色} {菊花 黄色}
f2地址为 0xc000060540,f3 地址为0xc0000605c0
修改后： {杏花 黄色} {菊花 黄色}
-----------------------
函数 getFlower2 内 temp：main.Flower, {玫瑰 红色}, 0xc0000606c0
函数 getFlower2 内 f：*main.Flower, &{玫瑰 红色}, 0xc00000a038
函数 getFlower2 内 temp：main.Flower, {玫瑰 红色}, 0xc000060740
函数 getFlower2 内 f：*main.Flower, &{玫瑰 红色}, 0xc00000a040
修改前： &{玫瑰 红色} &{玫瑰 红色}
修改后： &{樱花 红色} &{玫瑰 红色}
一定要动手写一边，一边写一边执行，观察变化，哪里不同。
匿名结构体和匿名字段
匿名结构体
匿名结构体就是没有名字的结构体，不用通过type 关键字定义就可以直接使用。
创建匿名结构体时，同时要创建对象。匿名结构体由结构体定义和键值对初始化两部分组成，语法如下：
variableName := struct {
// 成员属性
}{
// 初始化成员属性
}
匿名结构体案例
package main
import (
"fmt"
"math"
)
func main() {
// 匿名函数
res := func(m, n float64) float64 {
return math.Pow(m, n)
}(2, 3)
fmt.Println(res)
// 匿名结构体
add := struct {
province, city string
}{"湖北省", "武汉市"}
fmt.Println(add)
}
结构体的匿名字段
匿名字段就是在结构体中的字段没有名字，只包含一个没有字段名的类型，这些字段就是匿名字段。
若字段没有名字，则默认使用类型作为字段名，同一个类型只能有一个匿名字段。
package main
import "fmt"
func main() {
// 实例化结构体
user := User{"王美丽", 19, 168.7}
fmt.Println(user)
fmt.Printf("名字：%s\n", user.string)
fmt.Printf("年龄：%d\n", user.int8)
fmt.Printf("身高：%.2f\n", user.float64)
}
type User struct {
string
int8
float64
}
看到案例应该发现一个问题了，匿名字段很不好你，完全不知道它代表啥子鬼东西。
嵌套结构体
将结构体作为另一个结构体的属性，这种结构就是结构体嵌套。
结构体嵌套可以模拟面向对象编程中的两种关系：
1、聚合关系：一个类作为另一个类的属性；
2、继承关系：一个类作为另一个类的子类。
嵌套结构体-聚合关系
package main
import "fmt"
func main() {
// 模拟对象之间的聚合关系
p := Person{}
p.name = "王美丽"
p.age = 19
// 地址赋值
addr := Address{}
addr.province = "湖北"
addr.city = "武汉"
p.address = &addr
fmt.Println(p)
fmt.Println("姓名：", p.name, " 年龄:", p.age, "省：", p.address.province, "市：", p.address.city)
fmt.Println("-------------")
// 修改 Person 对象嵌套对象的数据会影响原数据
p.address.city = "宜昌"
fmt.Println("姓名：", p.name, " 年龄:", p.age, "省：", p.address.province, "市：", p.address.city, "addr.cidy", addr.city)
fmt.Println("-------------")
// 修改 Address 中的数据，会影响到 Person 使用的嵌套数据
addr.city = "襄阳"
fmt.Println("姓名：", p.name, " 年龄:", p.age, "省：", p.address.province, "市：", p.address.city, "addr.cidy", addr.city)
}
type Address struct {
province, city string
}
type Person struct {
name string
age int8
address *Address
}
输出结果
{王美丽 19 0xc0000603c0}
姓名： 王美丽 年龄: 19 省： 湖北 市： 武汉
-------------
姓名： 王美丽 年龄: 19 省： 湖北 市： 宜昌 addr.cidy 宜昌
-------------
姓名： 王美丽 年龄: 19 省： 湖北 市： 襄阳 addr.cidy 襄阳
传递嵌套关系时，若不使用引用方式传递时，不会互相影响。这个案例使用了 &addr 进行传递指针，因此彼此受到影响。
嵌套结构体-继承关系
在结构体中，属于匿名结构体的字段称为提升字段，它们可以被访问，匿名结构体就像是该结构体的父类。
采用匿名字段的形式就是模拟继承关系。而模拟聚合关系时一定要采用有名字的结构体作为字段。
package main
import "fmt"
func main() {
// 1、实例化并初始化 Person2
p2 := Person2{"王美丽", 32, "女"}
fmt.Println(p2)
fmt.Println("--------------------")
// 2、实例化并初始化 Student
// 写法一
s1 := Student{p2, "中国人民大学"}
printInfo(s1)
// 写法二
s2 := Student{Person2{"郝帅", 40, "男"}, "上海交通大学"}
printInfo(s2)
// 写法三
s3 := Student{Person2: Person2{
name: "王大美",
age: 42,
sex: "女",
},
schoolName: "武汉大学",
}
printInfo(s3)
// 写法四
s4 := Student{}
s4.name = "Lcuy"
s4.sex = "女"
s4.age = 30
s4.schoolName = "华中师范大学"
printInfo(s4)
}
type Person2 struct {
name string
age int8
sex string
}
type Student struct {
Person2
schoolName string
}
func printInfo(s Student) {
fmt.Println(s)
fmt.Printf("%+v\n", s)
fmt.Printf("姓名：%s, 年龄：%d, 性别：%s, 学校：%s\n", s.name, s.age, s.sex, s.schoolName)
fmt.Println("--------------------")
}
输出结果
{王美丽 32 女}
--------------------
{{王美丽 32 女} 中国人民大学}
{Person2:{name:王美丽 age:32 sex:女} schoolName:中国人民大学}
姓名：王美丽, 年龄：32, 性别：女, 学校：中国人民大学
--------------------
{{郝帅 40 男} 上海交通大学}
{Person2:{name:郝帅 age:40 sex:男} schoolName:上海交通大学}
姓名：郝帅, 年龄：40, 性别：男, 学校：上海交通大学
--------------------
{{王大美 42 女} 武汉大学}
{Person2:{name:王大美 age:42 sex:女} schoolName:武汉大学}
姓名：王大美, 年龄：42, 性别：女, 学校：武汉大学
--------------------
{{Lcuy 30 女} 华中师范大学}
{Person2:{name:Lcuy age:30 sex:女} schoolName:华中师范大学}
姓名：Lcuy, 年龄：30, 性别：女, 学校：华中师范大学
--------------------
在这个案例中，Person2 相当是一个父类，而 Student 就是一个子类，该子类继承了Person2，因此可以直接使用父类中的 schoolName 属性。
命名冲突
当两个字段拥有相关的名字时会产生冲突，一般有两种情况：
1、外层字段的名字覆盖内层字段的名字，但两者的内存空间都会保留，这提供了一种重载字段 或方法的方式；
2、相同的名字在同层次结构体中出现了重复，并且这个字段被程序调用了，这将导致程序错误。
请登录后再评论