9-Go基础：结构体与指针

已于 2022-04-25 18:21:10 修改
阅读量1k 收藏 2
点赞数 2
分类专栏： Go语言基础 文章标签： go
于 2022-04-25 17:44:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq23001186/article/details/124405087
版权

目录

一、结构体

1 - 结构体创建与初始化

  • 结构体概念：结构体是由一系列具有相同类型或不同类型的数据构成的数据集合
  • 结构体应用场景：结构体可以很好地管理一批有联系的数据，使用结构体可以提高程序的易读性
  • 结构体创建语法
type 结构体名 struct {
	成员名 数据类型
	...................
}
  • 结构体初始化的方式
    • 顺序初始化：顺序初始化:每个成员必须初始化，在初始化时，值的顺序与结构体成员的顺序保持一致
    • 指定成员初始化
    • 通过“结构体变量.成员” 完成初始化
func main() {
	// 成员名称前面不能添加var
	type Student struct {
		id   int
		name string
		age  int
		addr string
	}
	// 顺序初始化
	var s Student = Student{101, "张三", 18, "北京"}
	fmt.Println(s)

	// 指定成员初始化，部分初始化
	var s1 Student = Student{name: "李四", age: 18}
	fmt.Println(s1)

	// 通过“结构体变量.成员” 完成初始化
	var stu Student
	stu.id = 102
	stu.name = "老王"
	stu.age = 28
	stu.addr = "北京"
	fmt.Println(stu)
}

2 - 结构体数组

  • 结构体数组定义：var 结构体数组名 [下标] 结构体类型
  • 修改结构体数组成员的值：结构体数组名[下标].成员=值
  • 结构体数组遍历
    • for…len() 进行遍历
    • for…range 进行遍历
type Student struct {
	id   int
	name string
	age  int
	addr string
}

func main() {
	var arr [3]Student = [3]Student{
		Student{101, "张三", 18, "北京"},
		Student{102, "李四", 18, "北京"},
		Student{103, "王五", 19, "北京"},
	}
	fmt.Println(arr)

	fmt.Println(arr[0])
	fmt.Println(arr[0].age)
	arr[0].age = 20
	fmt.Println(arr)

	// 通过循环来输出结构体数组中的内容。
	for i := 0; i < len(arr); i++ {
		fmt.Println(arr[i].age)
	}

	for k, v := range arr {
		fmt.Println(k)
		fmt.Println(v.age)
	}
}

3 - 结构体切片

  • 结构体切片定义：var 结构体切片名 [ ] 结构体类型
  • 修改结构体切片成员的值：结构体切片名[下标].成员=值
  • 结构体切片遍历
    • for…len() 进行遍历
    • for…range 进行遍历
  • append函数使用：向结构体切片末尾追加数据
type Student struct {
	id   int
	name string
	age  int
	addr string
}

func main() {

	var s []Student = []Student{
		Student{101, "张三", 18, "北京"},
		Student{102, "李四", 18, "北京"},
	}

	fmt.Println(s[0])
	fmt.Println(s[0].age)
	s[0].age = 20
	fmt.Println(s)

	// 循环遍历
	for i := 0; i < len(s); i++ {
		fmt.Println(s[i].name)
	}
	for k, v := range s {
		fmt.Println(k)
		fmt.Println(v.id)
	}

	// 追加数据
	s = append(s, Student{103, "王五", 20, "北京"})
	fmt.Println(s)
}

4 - 结构体map

  • 结构体map定义：make(map[key的类型]值的类型)
  • 结构体map初始化：map名字[键]=值
  • 结构体map循环遍历：通过for…range方式进行遍历
  • 删除map中的值：delete(map名字,键)
type Student struct {
	id   int
	name string
	age  int
	addr string
}

func main() {
	m := make(map[int]Student)
	m[1] = Student{101, "张三", 18, "北京"}
	m[2] = Student{102, "李四", 18, "北京"}
	fmt.Println(m)
	fmt.Println(m[1])
	fmt.Println(m[1].name)

	delete(m, 2)
	fmt.Println(m)

	for key, value := range m {
		fmt.Println(key)
		fmt.Println(value.age)
	}
}

5 - 结构体作为函数参数

  • 结构体作为函数参数：在函数中修改结构体成员值，不会影响到原结构体
type Student struct {
	id   int
	name string
	age  int
	addr string
}

func main() {
	stu := Student{101, "张三", 18, "北京"}
	PrintDemo(stu)
	fmt.Println(stu) // {101 张三 18 北京}
}

func PrintDemo(stu Student) {
	stu.age = 20
	fmt.Println(stu) // {101 张三 20 北京}
}

二、指针

1 - 指针定义

  • 指针概念：指针也是一个变量，但它是一种特殊的变量，因为它存储的数据不仅仅是一个普通的值（如简单的整数或字符串），而是另一个变量的内存地址

在这里插入图片描述

  • 指针变量定义语法：var 指针变量名 *类型
  • 通过指针间接修改变量的值：* 指针变量 = 值
func main() {
	var a int = 10
	var p *int
	p = &a
	fmt.Printf("%p\n", &a) // 0xc00000a0a8
	fmt.Printf("%p\n", p)  // 0xc00000a0a8
	fmt.Printf("%p\n", &p) // 0xc000006028
	fmt.Println(*p)        // 10
	*p = 222
	fmt.Println("a=", a) // 222
}

2 - 指针操作注意事项

  • 空指针
func main() {
	var p *int
	fmt.Println(p) // <nil>
}
  • 不要操作没有合法指向的内存
func main() {
	var p *int
	*p = 78
}
  • new函数使用：开辟数据类型对应的内存空间，返回值为数据类型指针
func main() {
	var p *int
	p = new(int)
	*p = 67
	fmt.Println(*p)
}

3 - 指针变量作为函数参数

func main() {
	var num int = 10
	Update(&num)
	fmt.Println(num)
}
func Update(p *int) {
	*p = 60
}

4 - 数组指针

  • 数组指针定义：var 数组指针变量 *[下标] 类型
func main() {
	nums := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	var p *[10]int
	p = &nums
	fmt.Println(*p)      // 获取整个数组中的内容，[1 2 3 4 5 6 7 8 9 10]
	fmt.Println((*p)[3]) // []的运算优先级高于*，4
	fmt.Println(p[0])    // 1
	for i := 0; i < len(p); i++ {
		fmt.Println(p[i])
	}

	UpdateArr(p)
	fmt.Println(nums)
}
func UpdateArr(p *[10]int) {
	p[0] = 100
}

5 - 指针数组

  • 指针数组概念：数组元素是指针类型
    • 指针数组指的是一个数组中存储的都是指针（也就是地址）。也就是一个存储了地址的数组
  • 指针数组定义语法：var 数组名 [下标]*类型
  • 指针数组根据具体地址获取对应的值：* 指针数组名[下标]
func main() {
	var p [2]*int
	var i int = 10
	var j int = 20
	p[0] = &i
	p[1] = &j
	fmt.Println(p)
	fmt.Println(*p[0]) // 不要加括号
	fmt.Println(*p[1])
	//循环
	for i := 0; i < len(p); i++ {
		fmt.Println(*p[i])
	}
	for k, value := range p {
		fmt.Println(k)
		fmt.Println(*value)
	}
}

6 - 切片指针

  • 切片指针概念：定义指针，指向切片
func main() {
	s := []int{1, 2, 3, 4, 5, 6}
	var p *[]int
	p = &s
	fmt.Println(*p)
	fmt.Println((*p)[0])
	//fmt.Println(p[0]) //错误，这个与数组指针不同

	// 切片指针修改切片的元素
	(*p)[0] = 200
	fmt.Println(s)

	//切片指针遍历
	for i := 0; i < len(*p); i++ {
		fmt.Println((*p)[i])
	}

	for k, value := range *p {
		fmt.Println("k=", k)
		fmt.Println("value=", value)
	}
}

7 - 结构体指针

  • 结构体指针概念：定义指针，指向结构体
  • 结构体指针作为函数：在函数中修改结构体的成员的值，会影响原结构体成员的值
type Student struct {
	id   int
	name string
	age  int
}

func main() {
	stu := Student{101, "张三", 18}
	var p *Student
	p = &stu

	fmt.Println(*p)
	fmt.Println((*p).name)
	fmt.Printf("p.name=%s\n", p.name) // 简化的结构体指针写法

	// 修改结构体中的值
	p.age = 20
	fmt.Println(stu) // {101 张三 20}
	UpdateStruct(p)
	fmt.Println(stu) // {101 张三 21}
}
func UpdateStruct(stu *Student) {
	stu.age = 21
}

8 - 多级指针（简单了解）

func main() {
	var a int = 10
	var p *int //一级指针
	p = &a

	var pp **int
	pp = &p
	**pp = 200
	fmt.Println(a) // 200
}

三、基础加强

1 - 深浅拷贝

  • 浅拷贝：仅仅拷贝的是变量的值，没有对指向的空间进行任何的拷贝
  • 深拷贝：将原有的变量的空间全部拷贝一份（GO语言几乎很少用到）
  • 函数传参是浅拷贝
func main() {
	var num int = 10
	ap := &num
	Update(ap)
	fmt.Println(num)
}
func Update(p *int) {
	*p = 60
}

2 - 切片传参

  • 把切片作为参数可以修改切片中的元素，原因分析
    • 切片的底层本身就是一个结构体
    • Modify传参的时候使用浅拷贝，将结构体的地址传递给了Modify函数
  • 通过append方法对切片进行动态扩容
    • append 当容量不足的时候会动态分配内存，这块内存是一个新的内存
func main() {
	s := make([]int, 5, 5)
	Modify(s)
	fmt.Println(s) // [0 0 0 0 0]
}
func Modify(sli []int) {
	for i := 0; i < 5; i++ {
		sli = append(sli, i)
	}
	fmt.Println("sli:", sli) // sli: [0 0 0 0 0 0 1 2 3 4]
}

3 - for…range分析

  • range 的本质是一个函数方法，使用时候可以加括号使用
func main() {
	v := [3]int{1, 2, 3}
	for i, value := range (v) { //对形参进行遍历
		v[i] = 3
		// 输出打印遍历值
		fmt.Println("value:", value) // 1 2 3
	}
	// 打印切片的值
	fmt.Println("v", v) // v [3 3 3]
}
  • 修改range得到后的value，不影响原始切片或者数组
type Student struct {
	Name string
	Age  int
}

func main() {
	// 定义一个student 类型切片
	stu1 := Student{"MrWang", 100}
	stu2 := Student{"MrSun", 50}
	stu3 := Student{"MrQiu", 25}
	v := []Student{stu1, stu2, stu3}
	// 循环遍历 数组
	for _, value := range v {
		value.Age = value.Age + 1000 // 对每个人的年龄进行更新
	}
	// 打印切片的值
	fmt.Println(v) // [{MrWang 100} {MrSun 50} {MrQiu 25}]
}
无休止符
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Go语言指针访问结构体的方法
09-22
主要介绍了Go语言指针访问结构体的方法,涉及Go语言指针及结构体的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
一文了解 Go 中的指针和结构体
cmy_top的博客
11-25 1397
前面的两篇文章对 Go 语言的基础语法和基本数据类型以及几个复合数据类型进行介绍，本文将对 Go 里面的指针和结构体进行介绍，也为后续文章做铺垫。
Go语言结构体指针
qq_54650406的博客
09-14 1337
golang结构体指针
Go最全Go-结构体类型详解（声明、初始化、结构体指针、方法，2024年最新掌握了这些Golang高级工程师必备知识
最新发布
2401_84904581的博客
05-16 493
构造函数使用工厂模式，根据属性来进行对象的创建。选中首字母小写的属性，右键点击Generate或快捷键Alt+Insert。3)对于方法，形参为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以，内部属性是否改变取决于形参。去除了C++等语言的的继承、方法重载、构造函数、析构函数、隐藏的this指针，很简洁。2)对于普通函数，形参为值类型时，不能将指针类型的数据直接传递，反之亦然。，这与Go一贯的显示转换不同，个人并不喜欢。得到结构体的地址，就是结构体指针。使用{key:value}形式。
Golang结构体遍历
q302989778的博客
01-27 4814
func ForeachStruct(obj interface{}) { t := reflect.TypeOf(obj) // 注意，obj不能为指针类型，否则会报：panic recovered: reflect: NumField of non-struct type v := reflect.ValueOf(obj) for k := 0; k < t.NumField(); k++ { fmt.Printf("%s -- %v \n", t.Field(k).Tag, v.Fi.
golang结构体指针
知行合一
07-20 2553
1、由于结构体是值类型,在方法传递时希望传递结构体地址,可以使用结构体指针完成，结合new(T)函数创建结构体指针 peo := new(People) //因为结构体本质是值类型,所以创建结构体指针时已经开辟了内存空间 fmt.Println(peo == nil) //输出:false //由于结构体中属性并不是指针类型,所以可以直接调用 peo.Name = "jeff" fmt.Println(peo)//输出:&{jeff 0} peo1:=peo peo1.Name="高级语言" fmt
桫哥-GOlang基础-Go语言实战：驾考系统
06-12
《Go语言实战：驾考系统》是一门针对Go语言初学者和进阶者的教程，旨在帮助学习者从零开始，逐步掌握Go语言的基础语法，并通过实战案例深化理解，提升编程能力。课程风格轻松活泼，注重理论与实践的结合，鼓励创新...
桫哥-GOlang基础-Go语言实战：多人聊天室（上）
06-12
在本课程"桫哥-GOlang基础-Go语言实战：多人聊天室（上）"中，我们将深入学习Go语言的基础语法以及如何运用这些基础知识来构建一个多人聊天室的实战项目。Go语言，又称为Golang，是Google在2009年推出的一种静态类型...
go代码-Go 结构体指针
07-14
本篇文章将深入探讨Go语言中的结构体指针及其相关知识点。 1. **定义结构体** 在Go中，你可以通过`type`关键字定义一个新的结构体类型，例如： ```go type Person struct { Name string Age int } ``` 这...
go语言反射
.
12-11 230
go语言反射 反射的类型对象（reflect.Type） 在Go程序中，使用reflect.TypeOf()函数可以获得任意值的类型对象（reflect.Type），程序通过类型对象可以访问任意值的类型信息。 反射的类型（Type）与种类（Kind） 在使用反射时，需要首先理解类型（Type）和种类（Kind）的区别。编程中，使用最多的是类型，但在反射中，当需要区分一个大品种的类型时，就会用到种类（Kind）。例如，需要统一判断类型中的指针时，使用种类（Kind）信息就较为方便。 Go程序中的类型（Type
用Go语言 遍历结构体的字段和调方法 （反射最佳实践） (Golang经典编程案例)
热门推荐
数据知道的博客
07-08 4万+
案例：使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值。 package main import ( "fmt" "reflect" ) //定义Monster结构体 type Monster struct { Name string `json:"name"` Age int `json:"monster_age"` Score float32 `json:"成绩"...
Go指针与结构体
qq_45371023的博客
02-20 254
指针和结构体，指针概念，如何使用。数组指针，指针函数，指针作为参数；结构体，定义一个结构体，匿名结构体，结构体嵌套，结构体导出。
十、Go语言中的结构体详解
阿澈不吃蒜的博客
07-28 2133
在 Go 语言中有一些基本的数据类型，如 string、整型、浮点型、布尔等数据类型， Go 语言中可以使用 type 关键字来定义自定义类型。
golang学习笔记系列之指针和结构体
max_LLL的博客
09-24 876
类型定义语法my_type：自己新定义的类型old_type：已经存在的类型类型别名语法type my_type = old_type //用已存在的类型赋值给新类型两者的区别类型定义相当于定义了一个全新的类型，与之前的类型不同；但是类型别名并没有定义新的类型，而是使用一个别名来代替之前的类型类型别名只会在代码中存在，在编译完成之后并不会存在该别名因为类型别名和原来的类型是一致的，所以原类型所拥有的方法，类型别名定义的变量也拥有；但是如果是重定义的一个类型，那么不可以调用之前的任何方法。
golang笔记-struct体遍历
Tooth_Fairy的博客
11-22 4316
由于文章由markdown的方式编写, 部分链接与图片显示可能存在问题, 大家可以移步到github源查看 文章由https://studygolang.com/articles/5837启发, 进行展开发散. 利用reflect包对struct结构进行遍历, 对于学习golang有很大的帮助: 完整测试代码如下, 可以用以输出完整的struct成员, 增加递归函数可以很容易的做到多种类型输...
Go语言自学系列 | golang标准库os模块 - File文件写操作
COCO_gsta的博客
03-21 1084
视频来源：B站《golang入门到项目实战 [2021最新Go语言教程，没有废话，纯干货！持续更新中...]》 一边学习一边整理老师的课程内容及试验笔记，并与大家分享，请移步至知乎网站，谢谢支持！ 附上汇总贴：Go语言自学系列 | 汇总 - 知乎 (zhihu.com)https://zhuanlan.zhihu.com/p/484035621 这里结束和File结构体相关的文件写操作 package main import ( "os" ) // 写字节数组 fu.
Go: struct 结构体类型和指针【学习笔记记录】
m0_63622279的博客
03-09 680
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。type 结构体名 struct {// 成员变量 成员变量名 数据类型 }var 指针数组名 [ size ] * 数据类型与指针变量声明格式基本一致，只是指针数组多了数组长度。// 定义一个整型数组，然后使用指针数组分别指向里面的每个数组元素 var numbers = [ ] int {
Golang 学习十六（结构体链表）
shenyuanhaojie的博客
04-09 986
文章目录1. 存储方式2. 链表更新2.1 链表定义2.2 将遍历链表封装成函数2.3 尾部添加元素（结构体节点）2.4 头部添加元素2.5 插入元素2.6 删除元素 概念：结构体是自定义复杂数据结构，struct 里面可以包含多个字段(属性)，struct 类型可以定义方法，和函数有区分，struct 属于值类型，且可以做嵌套，Go 中没有 Class 类型，只有 struct 类型。 示例：回顾结构体定义 package main import "fmt" type Car struct {
Go语言编程笔记4：结构体和切片
梦幻天空
11-08 3082
Go语言编程笔记4：结构体和切片 图源：wallpapercave.com 结构体 Go语言最主要使用的复合结构是结构体，我记得C和C++也是有结构体的，不过在C++中并不常用。事实上从语言继承的关系来说，Go语言与C语言是一脉相承的，所以又被称为类C语言。 定义 定义一个结构体就像是定义一个新的类型，只不过结构体一般会在结构体内部定义一些额外字段： package main type Pointer struct { x int y int } 这里需要注意的是，虽然Go语言里的结构体可以类比为
【GO语言卵细胞级别教程】02.GO变量和数据类型
01-21
【GO语言卵细胞级别教程】02.GO变量和数据类型

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

无休止符

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值