GO总结四容器与结构体

一 常用容器

1 数组
定义方法

var 数组名[大小] 类型

例子

package main

import "fmt"//导入包必须使用，否则编译报错

func main() {//g语言中的 ‘{’ 不能独占一行
	var arr[4]int;
	fmt.Println("arr:",arr)
	
	var arr2 = [4]int{1,2,3,4}
	fmt.Println("arr2:",arr2)	
	fmt.Println("arr == arr2",arr == arr2)//可以直接比较
	
	var arr3 = [...]int{1,3,5}//自动推导大小
	fmt.Println("arr3:",arr3)
		
	arr4 := [3][4]int{{2:10} ,{4, 5, 6, 7}}   
	 fmt.Println("arr4:",arr4)	
}

结果

数组初始化很灵活。

2 切片
底层就是数组

例子

package main

import "fmt"//导入包必须使用，否则编译报错

func main() {//g语言中的 ‘{’ 不能独占一行	
	//make创建
	slice1 := make([]int,5,10)//make(类型，长度，容量)
	fmt.Println("")
	fmt.Println("slice1:",slice1)
	
	//自动推导并初始化
	slice2 := []int{1,2,3,4}//起始位，结束位，容量
	fmt.Println("slice2:",slice2)
	
	//切片截取 
	var arr = [6]int{1,2,3,4,5,6}
	fmt.Println("arr:",arr)
	
	slice3 := arr[3:]//数组下标3之后的
	fmt.Println("slice3:",slice3)
	
	slice4 := arr[:3]//数组下标3之前的
	fmt.Println("slice4:",slice4)

	slice5 := arr[3:5]//数组下标3和5之间的
	fmt.Println("slice5:",slice5)
	slice5[1]=100
	fmt.Println("arr:",arr)//数组也会改变
	
	
}

结果

3 map
和你所熟悉的其他语言map是差不多的
例子

package main

import "fmt"//导入包必须使用，否则编译报错

func main() {//g语言中的 ‘{’ 不能独占一行	
	//make创建
	map1 := make(map[int]string)//创建一个map，key是int，value是string
	map1[1]="111"
	fmt.Println("map1:",map1)
	
	for key,value := range map1{
	
		fmt.Printf("key = %d,value = %s\n",key,value)
	}
	
	//自动推导
	//map2 := map[int]string	
	
}

结果

二 容器做参数

package main

import "fmt"//导入包必须使用，否则编译报错

func ChangeArr(arr[4]int){
	arr[1]= 10
	fmt.Println("ChangeArr arr:",arr)	
}

func ChangeArr1(arr*[4]int){
	arr[1]= 10
	fmt.Println("ChangeArr1 arr:",arr)	
}

func ChangeSlice(sli[]int){
	sli[1]= 10
	fmt.Println("ChangeSlice sli:",sli)	
}

func ChangeMap(mmap map[int]string){
	mmap[1] = "99"
	fmt.Println("ChangeMap mmap:",mmap)	
}

func main() {//g语言中的 ‘{’ 不能独占一行
	
	arr := [4]int{1,2,3,4}
	ChangeArr(arr)
	fmt.Println("main arr:",arr)	
	
	ChangeArr1(&arr)
	fmt.Println("main arr:",arr)	
	
	slice :=[]int{1,2,3,4}
	ChangeSlice(slice)
	fmt.Println("main slice:",slice)
	
	mmap :=make(map[int]string)
	mmap[0] = "00"
	mmap[1] = "11"
	mmap[2] = "22"
	mmap[3] = "33"
	fmt.Println("main mmap:",mmap)
	ChangeMap(mmap)
	fmt.Println("main mmap:",mmap)

}

结果

map和切片是引用传递，数组是值传递

三 结构体

package main

import "fmt"//导入包必须使用，否则编译报错

type Student struct{
	id int
	name string

}

func ChangeStr(stu Student){
	stu.id = 11

}

func main() {//g语言中的 ‘{’ 不能独占一行
	 
	stu := Student{01,"张飞"}
	fmt.Println(stu)
	stu.id = 15
	fmt.Println(stu)
	
	var p1* Student
	p1 = &stu
	p1.id = 20
	fmt.Println(stu)
	
	(*p1).id = 25 //通过指针操作*p1和p1等价
	fmt.Println(stu)
		
	p2 := new (Student)
	p2.id = 10;
	p2.name = "小明"
	fmt.Println(p2)
	
	fmt.Println("p1 == p2",p1==p2)
	
	ChangeStr(*p2)
	fmt.Println("main",p2)
	
	
}

结果

结构体是值传递。
同时，先提一下，一个包里的结构体，结构体里的成员，一个方法，首字母如果是小写，相当于c++的私有变量，其他包不能用