Golang - 复合类型

目录

• Golang - 复合类型
  • 1. 指针
  • 2. new()和make()
  • 3. 数组
  • 4. slice
  • 5. Map
  • 6. 结构体
  • 7. 结构体参数

Golang - 复合类型

1. 指针

• go语言中指针是很容易学习的，比C中容易的多，它可以更简单地执行一些任务
• 与变量类似，使用前需要声明，使用&符号可以取内存地址
• 声明指针的格式：
  • var 指针变量名 *指针类型

指针的使用

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
	//声明变量
	var a int = 20

	//声明指针变量
	var p *int
	p = &a

	//十六进制
	fmt.Printf("a变量的地址是: %x\n", &a)
	fmt.Printf("p变量存储的指针地址: %x\n", p)

	//使用指针访问值
	fmt.Printf("*p变量的值: %d\n", *p)
}

//a变量的地址是: c042052080
//p变量存储的指针地址: c042052080
//*p变量的值: 20

通过指针修改变量

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
	//定义变量
	var num int = 10
	fmt.Println(&num)
	var ptr *int

	//指针赋值
	ptr = &num
	//通过指针修改num
	* ptr = 20
	fmt.Println(num)
}

//0xc042052080
//20

go空指针

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
	var ptr *int
	fmt.Println("ptr的值为:", ptr)

	//判断空指针
	if ptr == nil{
		fmt.Println("是空")
	}
}

//ptr的值为: <nil>
//是空

值传递和引用传递

void pass_by_val(int a){
a++;
}

void pass_by_ref(int& a){
a++;
}

int main() {
int a = 3;

pass_by_val(a);
printf("pass_by_val: %d\n", a)
printf("pass_by_ref: %d\n", a)
}

答案：3，4

值传递:

//package 声明开头表示代码所属包
package main

import "fmt"

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

func main() {
	a, b := 3, 4
	swap(a, b)
	fmt.Println(a, b)
}

// 3  4

go引用传递:

//package 声明开头表示代码所属包
package main

import "fmt"

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

func main() {
	a, b := 3, 4
	swap(&a, &b)
	fmt.Println(a, b)
}

// 4  3

2. new()和make()

• new()用来分配内存，但与其他语言中的同名函数不同，它不会初始化内存，只会将内存置零

• make(T)会返回一个指针，该指针指向新分配的，类型为T的零值，适用于创建结构体

• make()的目的不同于new()，它只能创建slice、map、channel，并返回类型为T（非指针）的已初始化（非零值）的值

  //package 声明开头表示代码所属包
  package main
  
  import "fmt"
  
  func main() {
  	p :=new([]int)
  	fmt.Println(p)
  
  	//[]int切片
  	//10: 初始化10个长度
  	//50: 容量为50
  	m :=make([]int, 10, 50)
  	fmt.Println(m)
  
  	m[0] = 10
  	(*p)[0] = 10
  	fmt.Println(p)
  }
  

3. 数组

声明变量:

var 数组名[数组长度] 数组类型

声明和初始化数组:

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
	//数组长度不让变化
	//定义int类型数组
	var arr1 [5]int

	//:=声明并赋值
	arr2 := [3]int{1, 2, 3}

	//可以省略大小
	arr3 := [10]int{2, 4, 6, 8, 10}
	fmt.Println(arr1, arr2, arr3)

	//定义二维数组
	var grid [4][5]int
	fmt.Println(grid)
}

//[0 0 0 0 0] [1 2 3] [2 4 6 8 10 0 0 0 0 0]
//[[0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]

数组是值类型还是引用类型?

package main

import "fmt"

//传入数组，修改元素
func printArr(arr [5]int)  {
   //修改一个元素
   arr[0] = 100
   for i,v := range arr{
      fmt.Println(i,v)
   }
}

func main() {
   //定义数组
   var arr1 [5]int

//:=声明并赋值
   arr2 := [3]int{1, 2, 3}
   //可以省略大小
   arr3 := [...]int{2, 4, 6, 8, 10}
   fmt.Println(arr1, arr2, arr3)

   //printArr(arr1)
   //报错
   //printArr(arr2)
   printArr(arr3)

   //打印原始值
   fmt.Println()
   fmt.Println(arr3)
}

4. slice

• 数组的长度在定义之后无法再次修改，go语言提供了数组切片（slice）来弥补数组的不足

• 创建切片的各种方式

    //package 声明开头表示代码所属包
    package main
  
    import "fmt"
  
    func main() {
    	//声明空切片
    	var s1 []int
  
    	//:=声明
    	s2 :=[]int{}
  
    	var s3 []int = make([]int, 0)
    	s4 :=make([]int, 0, 0)
    	fmt.Println(s1, s2, s3, s4)
    }
  
    [] [] [] []
  

.

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
	//定义数组
	arr :=[...]int{0, 1, 2, 3, 4, 5, 6, 7}

	//切片取值
	fmt.Println(arr[2:6])
	fmt.Println(arr[:6])
	fmt.Println(arr[2:])
	fmt.Println(arr[:])
}

//[2 3 4 5]
//[0 1 2 3 4 5]
//[2 3 4 5 6 7]
//[0 1 2 3 4 5 6 7]

go切片可以向后扩展, 但不能向前扩展

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
	//定义数组
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
	s1 := arr[2:6]
	fmt.Println(s1)
	s2 := s1[3:5]
	fmt.Println(s2)

	//切片添加元素
	s3 := append(s2,10)
	fmt.Println(s3)
	fmt.Println(arr)

	s4 := append(s3,11)
	fmt.Println(s4)
	fmt.Println(arr)
	s5:= append(s4,12)
	fmt.Println(s5)
	fmt.Println(arr)
}

//[2 3 4 5]
//[5 6]
//[5 6 10]
//[0 1 2 3 4 5 6 10]
//[5 6 10 11]
//[0 1 2 3 4 5 6 10]
//[5 6 10 11 12]
//[0 1 2 3 4 5 6 10]

内建函数copy()

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
	//切片
	data := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	s1 := data[8:]
	s2 := data[:5]
	fmt.Println(s1)
	fmt.Println(s2)

	//将第二个拷贝到第一个里
	copy(s2, s1)
	fmt.Println(s2)
	fmt.Println(data)
}

//[8 9]
//[0 1 2 3 4]
//[8 9 2 3 4]
//[8 9 2 3 4 5 6 7 8 9]

5. Map

• Map 是go内置的数据结构，是一种无序的键值对的集合，可以通过key快速找到value的值
• 定义Map：

  • var 变量名 map[key的数据类型] value的数据类型

  • 创建map

    	//package 声明开头表示代码所属包
    	package main
    
    	import "fmt"
    
    	func main() {
    		//声明map
    		var mmp map[int]string
    		fmt.Println(mmp == nil)
    
    		//m2和m3是等价的
    		m2 := map[int]string{}
    		m3 :=make(map[int]string)
    		fmt.Println(m2, m3)
    
    		m4 :=make(map[int]string, 10)
    		fmt.Println(m4)
    	}
    
    	//true
    	//map[] map[]
    	//map[]
    

初始化map

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
	//1. 定义同时初始化
	var m1 map[int]string = map[int]string{1:"超哥", 2:"最帅"}
	fmt.Println(m1)

	//2. 自动推导类型 :=
	m2 :=map[int]string{1:"超哥", 2:"最帅"}
	fmt.Println(m2)
}

//map[1:超哥 2:最帅]
//map[1:超哥 2:最帅]

键值操作

//package 声明开头表示代码所属包
package main

func main() {
	m1 :=map[int]string{1:"111",2:"222"}

	//修改
	m1[1]="1111"
	//追加
	m1[3]="333"
}

6. 结构体

• go语言没有class，只是个结构体struct
• 结构体定义：
  • type 结构体名 struct{}
• 结构体初始化

//package 声明开头表示代码所属包

package main

import "fmt"

//定义学生结构体
type Student struct {
	id int
	name string
	sex byte
	age int
	addr string
}

func main() {
	//1.顺序初始化
	var s1 Student = Student{1,"约汉",'f',18,"bj"}
	fmt.Println(s1)
	s2 := Student{2,"接客",'m',20,"sh"}
	fmt.Println(s2)
	//s3 := Student{3,"撸死",'m',25}

	//2.指定初始化成员
	s4 := Student{id:4,age:26}
	fmt.Println(s4)
	fmt.Println(s4.id)

	//3.结构体作为指针变量初始化
	var s5 *Student = &Student{5,"接客",'f',20,"sh"}
	fmt.Println(s5)
	//指针类型访问变量
	//go底层自己实现了转换，下面2种都可以取指针对象的属性
	fmt.Println((*s5).id)
	fmt.Println(s5.id)

	s6 := &Student{6,"接客",'m',20,"sh"}
	fmt.Println(s6)
}

//{1 约汉 102 18 bj}
//{2 接客 109 20 sh}
//{4  0 26 }
//4
//&{5 接客 102 20 sh}
//5
//5
//&{6 接客 109 20 sh}

7. 结构体参数

结构体可以作为函数参数传递

//package 声明开头表示代码所属包
package main

import "fmt"

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

//定义传递学生对象的方法
func tmpStudent(tmp Student) {
	//修改id
	tmp.id = 250
	fmt.Println("tmp=", tmp)
}

//定义传递指针类型的对象的方法
func tmpStudent2(p *Student) {
	//修改id
	p.id = 249
	fmt.Println("tmp2=", p)
}

func main() {
	var s Student = Student{1, "接客", "female", 20, "sz"}
	tmpStudent(s)
	fmt.Println("main s =", s)
	//传递指针地址
	tmpStudent2(&s)
	fmt.Println("main s2=", s)
}

//tmp= {250 接客 female 20 sz}
//main s = {1 接客 female 20 sz}
//tmp2= &{249 接客 female 20 sz}
//main s2= {249 接客 female 20 sz}