Go语言基础第06天(结构体和指针)

1.练习

package main

import "fmt"

func main0101() {
    
    
	//ssdjfhjkahsjdsdj
	var arr [20]byte
	for i := 0; i < len(arr); i++ {
    
    
		fmt.Scanf("%c", &arr[i])
	}
	m := make(map[byte]int)

	for i := 0; i < len(arr); i++ {
    
    
		m[arr[i]]++
	}

	for k, v := range m {
    
    
		if v > 0 {
    
    
			//fmt.Println(k,v)
			fmt.Printf("%c  %d\n", k, v)
		}
	}
}

2.结构体定义和使用

type Student struct {
    
    
	id   int
	name string
	sex  string
	age  int
	addr string
}

func main0201() {
    
    

	//通过结构体名  定义结构体变量
	//var s Student
	结构体变量名.成员名
	//s.id=101
	//s.name="张飞"
	//s.sex="男"
	//s.age=28
	//s.addr="北京燕郊"
	//
	//fmt.Println(s)

	//var s Student=Student{101,"关羽","男",29,"山西运城"}
	s := Student{
    
    age: 30, id: 103, name: "刘备", addr: "巴蜀", sex: "男"}
	fmt.Println(s.id)
	fmt.Println(s.name)
	fmt.Println(s.sex)
	fmt.Println(s.age)
	fmt.Println(s.addr)
}

3.结构体的赋值和比较

type Students struct {
    
    
	id   int
	name string
	sex  string
	age  int
	addr string
}

func main0301() {
    
    
	s := Students{
    
    101, "貂蝉", "女", 18, "徐州"}

	//结构体变量赋值
	s1 := s

	s1.age = 22

	fmt.Println(s1)
	fmt.Println(s)

	//在结构体中使用== != 可以对结构体成员进行比较操作
	if s1 == s {
    
    
		fmt.Println("相同")
	} else {
    
    
		fmt.Println("不相同")
	}

	//大于 小于可以比较结构体成员

	if s.age > s1.age {
    
    
		fmt.Println("真")
	} else {
    
    
		fmt.Println("假")
	}

}

4.结构体数组和切片

type student struct {
    
    
	id    int
	name  string
	sex   string
	age   int
	score int
	addr  string
}

func main0401() {
    
    

	//var 结构体变量名 结构体类型

	//定义结构体数组
	//var 结构体数组名 [元素个数]结构体类型
	var arr [5]student

	//len(数组名)计算数组元素个数
	//fmt.Println(len(arr))

	for i := 0; i < len(arr); i++ {
    
    
		fmt.Scan(&arr[i].id, &arr[i].name, &arr[i].sex, &arr[i].age, &arr[i].score, &arr[i].addr)
	}

	//结构体 排序 根据结构体成员进行排序
	/*
		101 孙尚香 女 16 88 江东
	102 黄月英 女 28 90 襄阳
	103 大乔 女 26 70 江东
	104 小乔 女 24 60 江东
	105 甄姬 女 20 50 许昌
	*/

	for i := 0; i < len(arr)-1; i++ {
    
    
		for j := 0; j < len(arr)-1-i; j++ {
    
    
			//比较结构体成员 年龄  成绩
			if arr[j].score > arr[j+1].score {
    
    
				//结构体数组中的元素 允许相互赋值  将结构体成员中的所有数据进行相互交换

				//arr[j],arr[j+1]=arr[j+1],arr[j]
				//结构体成员依次交换  不建议采用
				//arr[j].id,arr[j+1].id=arr[j+1].id,arr[j].id
				//arr[j].name,arr[j+1].name=arr[j+1].name,arr[j].name
				//arr[j].sex,arr[j+1].sex=arr[j+1].sex,arr[j].sex
				//arr[j].score,arr[j+1].score=arr[j+1].score,arr[j].score
				//arr[j].age,arr[j+1].age=arr[j+1].age,arr[j].age
				//arr[j].addr,arr[j+1].addr=arr[j+1].addr,arr[j].addr
			}
		}
	}

	for i := 0; i < len(arr); i++ {
    
    
		fmt.Println(arr[i])
	}

}
func main0402() {
    
    
	//[元素个数]数组   []切片len
	arr := []student{
    
    {
    
    101, "曹操", "男", 58, 90, "许昌"},
		{
    
    102, "夏侯惇", "男", 40, 100, "荆州"},
		{
    
    103, "张辽", "男", 38, 99, "许昌"}}

	//在切片中添加数据

	arr = append(arr, student{
    
    104, "许褚", "男", 28, 99, "许昌"})
	arr = append(arr, student{
    
    105, "典韦", "男", 38, 99, "许昌"})
	for i, v := range arr {
    
    
		fmt.Println(i, v)
	}
}

5.结构体作为map的值

type stu struct {
    
    
	name  string
	age   int
	score int
}

func main0501() {
    
    

	//定义map
	m := make(map[int]stu)

	m[101] = stu{
    
    "周瑜", 28, 101}
	m[102] = stu{
    
    "孙策", 32, 78}

	//fmt.Println(m)
	for k, v := range m {
    
    
		fmt.Println(k, v)
	}

}
func main0502() {
    
    
	m := make(map[int][]stu)
	m[101] = append(m[101], stu{
    
    "曹操", 50, 88}, stu{
    
    "张辽", 38, 98}, stu{
    
    })
	m[102] = append(m[102], stu{
    
    "刘备", 50, 88}, stu{
    
    "张飞", 38, 98})
	m[103] = append(m[103], stu{
    
    "孙权", 50, 88}, stu{
    
    "甘宁", 38, 98}, stu{
    
    "太史慈", 38, 98})

	//m[101][1].name="张文远"
	for k, v := range m {
    
    
		for i, data := range v {
    
    

			if data.name == "张飞" {
    
    
				fmt.Println(k, i, data)
			}
			//fmt.Println("key:",k,"index",i,"value:",data)
		}
	}

}

6.结构体作为函数参数

type person struct {
    
    
	id    int
	name  string
	score int
	sex   string
}

func test(s person) {
    
    

	//fmt.Println(s.name)
	//fmt.Println(s.score)
	//fmt.Println(s.sex)
	s.name = "李逵"
}

func main0601() {
    
    

	stu := person{
    
    101, "宋江", 9, "男"}
	//结构体作为函数参数  值传递
	test(stu)

	fmt.Println(stu)

}
// 所有的切片都属于地址传递
func test1(stu []person) {
    
    

	stu[0].name = "晁盖"

}
func main() {
    
    
	//结构体切片
	stus := []person{
    
    {
    
    101, "宋江", 9, "男"},
		{
    
    102, "卢俊义", 99, "男"}}
	//为切片添加信息
	stus = append(stus, person{
    
    103, "吴用", 88, "男"})
	//结构体切片作为函数参数是地址传递
	//结构体数组作为函数参数是值传递
	test1(stus)

	fmt.Println(stus)
}

7.结构体实际开发使用

package main

/*
type skills struct{
	名称
	耗蓝
	CD 冷却时间
	范围
	伤害
}
定义结构体切片 保存技能信息

type role struct{
	名称
	等级 lv
	经验 exp
	钻石
	金币
	生命值 hp
	攻击力
	暴击
	防御
	蓝量mp
}
*/

/*
type 信用卡 struct{
	卡号
	持卡人姓名
	额度
	有效期
	密码
	银行信息
}

type 消费记录 struct{
	卡号
	消费时间
	消费id
	流水号
	消费金额
	备注
}
*/

func main0701() {
    
    

}

8.结构体练习

// 定义结构体存储5名学生 三门成绩 求出每名学生的总成绩和平均成绩
type stud struct {
    
    
	id    int
	name  string
	score []int //结构体成员为数组|切片
}

func main0801() {
    
    
	arr := []stud{
    
    {
    
    101, "小明", []int{
    
    100, 99, 88}},
		{
    
    102, "小红", []int{
    
    88, 56, 83}},
		{
    
    103, "小刚", []int{
    
    18, 57, 81}},
		{
    
    104, "小强", []int{
    
    48, 66, 93}},
		{
    
    105, "小花", []int{
    
    98, 50, 89}}}
	//五名学生
	for i := 0; i < len(arr); i++ {
    
    
		//三门成绩
		sum := 0
		for j := 0; j < len(arr[i].score); j++ {
    
    
			sum += arr[i].score[j]
		}
		fmt.Printf("第%d名学生总成绩为:%d 平均成绩:%d\n", i+1, sum, sum/3)
	}
}

9.指针变量定义和使用

func main0901() {
    
    
	var a int = 123

	//定义整型指针变量 指向a的地址
	//指针类型定义
	//var 指针 *数据类型  一级指针
	var p *int
	//将a的地址赋值给指针变量p
	p = &a

	//通过指针变量 间接访问变量对应的内存空间
	*p = 345
	fmt.Println(a)
	//fmt.Println(*p)
	//fmt.Println(p)
	//fmt.Println(&a)

}
func main0902() {
    
    
	//a:=10
	//p:=&a
	//
	//*p=123
	//fmt.Println(a)
	//fmt.Printf("%T",p)
	//声明了一个指针 默认值为nil(空指针 值为0)指向了内存地址编号为0 的空间
	//0-255为系统占用 不允许用户进行读写操作
	var p *int //空指针
	//p=a//err
	//p=0xc042058080//野指针  指针变量指向了一个未知的空间
	//访问野指针和空指针对应的内存空间都会报错
	//*p=123
	//*p=123//err
	fmt.Println(p)
}

10.指针变量的new

func main() {
    
    
	var p *int //nil
	fmt.Println(p)
	//为指针变量创建一块内存空间
	//在堆区创建空间
	p = new(int) //new 创建好的空间值为数据类型的默认值

	//打印p的值
	fmt.Println(p)
	//打印p指向空间的值
	fmt.Println(*p)

}

11.指针作为函数参数

//	func swap(a int, b int) {
    
    
//		a, b = b, a
//	}
//
// 函数参数为指针类型
func swap(a *int, b *int) {
    
    

	//*a  值
	//*a, *b = *b, *a
	temp := *a
	*a = *b
	*b = temp
}

func main1101() {
    
    

	a := 10
	b := 20
	//不能交换a b 的值  值传递
	//swap(a,b)
	//指针作为函数参数是地址传递
	swap(&a, &b)

	fmt.Println(a)
	fmt.Println(b)
}

猜你喜欢

转载自blog.csdn.net/qq_51685718/article/details/127393893