Go学习笔记之复合类型

指针类型

package main

import "fmt"

func main()  {
	a:=100
	var p *int//默认值为nil
	//不要操作没有合法指向的指针
	//*p=666
	p=&a
	fmt.Println(a,*p)
	fmt.Println(&a,p)
	*p=200
	fmt.Println(a,*p)
}

通过关键字new申请一块指定类型的存储空间并返回一个对应类型的指针

package main

import "fmt"

func main()  {
	var p *int
	//申请一块int类型的空间，并返回一个int型指针
	p=new(int)
	*p=100
	fmt.Println(*p)
	//自动推导类型
	q:=new(float32)
	*q=200
	fmt.Println(*q)
}

值传递和地址传递

package main

import "fmt"

func swap(a,b int)  {
	a,b=b,a
}

func main()  {
	a,b:=1,2
	fmt.Println(a,b)
	swap(a,b)
	fmt.Println(a,b)
}
//1,2和1,2

//地址传递才能实现真正的值交换
package main

import "fmt"

func swap(a,b *int)  {
	*a,*b=*b,*a
}

func main()  {
	a,b:=1,2
	fmt.Println(a,b)
	swap(&a,&b)
	fmt.Println(a,b)
}
//1,2和2,1

数组

package main

import "fmt"

func main()  {
	//定义一个大小为10的整形数组
	var array [10]int
	for i:=0;i<len(array);i++{
		array[i]=i+1
		fmt.Println(array[i])
	}
}

//第一种数组初始化形式
package main

import "fmt"

func main()  {
	var a [5]int=[5]int{1,2,3,4,5}
	for i:=0;i<len(a);i++{
		fmt.Println(a[i])
		fmt.Println(b[i])
	}
	//指定对应下标的值，其他下标自动赋值0
	b:=[5]int{1:10,3:20}
	for key,val:=range b{
		fmt.Println(key,val)
	}
}

数组作为函数参数

package main

import "fmt"

func modify(a [5]int)  {
	a[0]=10
	fmt.Println(a)
}

func main()  {
	a:=[5]int{1,2,3,4,5}
	//数组做函数参数时是值传递，将数组的值拷贝一份传递给其他函数，本身并不会被修改
	modify(a)
	fmt.Println(a)
}

package main

import "fmt"

func modify(p *[5]int)  {
	//地址传递的写法
	(*p)[0]=10
	fmt.Println(*p)
}

func main()  {
	a:=[5]int{1,2,3,4,5}
	fmt.Println(a)
	//将数组地址传递过去
	modify(&a)
	fmt.Println(a)
}

切片

切片是一种引用类型，类似于结构体，共包含三种数据：指向slice的指针；容量；长度

package main

import "fmt"

func main()  {
	array:=[6]int{1,2,3,4,5,6}
	//定义切片
	slice1:=[]int{}
	//array[start:end:cap]
	//len=end-start  已使用容量
	//cap=cap-start  切片容量
	s:=array[0:4:5]
	fmt.Println(s)
	fmt.Println("len(array):",len(array))
	fmt.Println("len(s):",len(s))
	fmt.Println("cap(s):",cap(s))
	//对于一个引用的改变，其他也都会发生改变
	s1 :=array[:]
	s2 :=array[:3]
	//使用make来构造切片make(slice,len,cap)
	s3 :=make([]int,len,cap)
	s3=append(s3, s2...)//向一个切片中添加另一个切片
	s3.append(s3,12)//容量扩充按照两倍的容量扩充
}

copy()的使用

package main

import "fmt"

func main()  {
	src:=[]int{1,2,3,4}
	des:=[]int{6,7,8,9,0}
	//按照顺序依次覆盖
	copy(des,src)
	fmt.Println(src)//[1,2,3,4]
	fmt.Println(des)//[1,2,3,4,0]
}

map用法

map是一个引用类型，因此对于map的所有修改都是保持一致的

package main

import "fmt"

func main()  {
	map1:= map[int]string{}
	map1[0]="liuzaishi"
	map1[1]="wangbizi"
	map1[2]="jinzhongguo"
	fmt.Println(map1)
	map2:= map[string]int{"songzhixiao":40,"liguangshu":36,"quanshaomin":35}
	fmt.Println(map2)
}

package main

import "fmt"

func main()  {
	//m1:=make(map[int]string)
	m1:= map[int]string{1:"liuzaishi",2:"jinzhongguo",3:"liguangshu"}
	//使用for each遍历map
	for key,val :=range m1{
		fmt.Println("key:value",key,val)
	}
	//判断对应的key是否存在
	value,ok:=m1[0]
	if ok{
		fmt.Println(value)
	}else{
		fmt.Println("不存在")
	
	//删除map中指定key的数据项
	delete(m1,1)
}

结构体类型

package main

import "fmt"

type Student struct {
	id int
	name string
	gender string
	score int
}

func main()  {
	//顺序初始化，必须对所有成员进行初始化
	var stu1 Student=Student{1,"zhangsan","F",89}
	var stu2 Student=Student{2,"lisi","M",90}
	fmt.Println("stu1:",stu1)
	fmt.Println("stu2",stu2)
	//指定成员初始化，其余成员赋值为对应的零值
	stu3:=Student{id:3,name:"wangwu"}
	fmt.Println(stu3)
	//结构体指针类型
	p1:=&Student{4,"zhaoyun","M",99}
	fmt.Println(p1)
}

结构体类型的引用传递和值传递

package main

import "fmt"

type Student struct {
	id int
	name string
	gender string
	score int
}

func test01(s Student)  {
	s.id=99
	fmt.Println(s)
}

func test02(s *Student)  {
	s.id=88
}

func main()  {
	//顺序初始化，必须对所有成员进行初始化
	var stu1 Student=Student{1,"zhangsan","F",89}
	var stu2 Student=Student{2,"lisi","M",90}
	//不会修改对象的值
	test01(stu1)
	fmt.Println(stu1)
	//会修改原对象的值
	test02(&stu2)
	fmt.Println(stu2)
}