5 复合数据类型

[TOC]

复合数据类型

Go基本复合数据类型有指针、数组、slice、map、struct、chan、interface。

• 其中指针本身和数组、struct是值类型，slice、map、chan、interface是引用类型。

指针

指针本质上是内存地址，一般为内存中存储变量值的起始位置。

• 指针变量就是存储内存地址的变量。

• 指针是对内存数据的一种引用。

• 指针代表一个变量的地址和类型，如果变量类型是T，那指向它的指针就是一个指向T的指针类型。

指针的优势

• 大量数据作为函数参数传递时，传递数据的指针最为高效，不需要对数据进行值拷贝，速度更快、内存占用更低。

声明指针

指针声明类型为*T，Go支持多级指针**T，通过&获取变量的地址。

• *T出现再“=”左边表示指针声明，*T出现在“=”右边表示取指针指向的值。

	a := 100
	p := &a
	c := *p
	fmt.Println(a) // 100
	fmt.Println(p) // 0x.....地址
	fmt.Println(c) // 100

• Go为实现自动垃圾回收禁止了指针运算，在C和C++中指针运算问题较多。

	a := 100
	p := &a
	p++	// 无法通过编译 Invalid operation: p++ (non-numeric type *int)
	fmt.Println(p)

• Go编译器通过“栈逃逸”机制将函数中的局部变量分配在堆上

func f1() *int{
	p := 100
	return &p
}
func main() {
	r := f1()
	fmt.Println(*r) // 100
}

栈逃逸机制

在函数栈之外共享一个值时，它将被分配在堆上。逃逸分析算法的工作是找到这些情况，并在程序中确保对任何值的访问是准确、一致和高效的。

• 编译器在编译阶段确立一个变量要放堆上还是栈上要看是否有在*其它地方（非局部）*被引用，有被引用那么它一定分配到堆上，否则分配到栈上。没有被外部引用，但对象太大导致无法存放在栈区上，依然有可能分配到堆上。

• 如果变量都分配到堆上会出现垃圾回收（GC）的压力不断增大，申请、分配、回收内存的系统开销增大，动态分配内存会产生一定量的内存碎片。频繁申请并分配堆内存是有一定 “代价” 的，会影响应用程序运行的效率，间接影响到整体系统，因此要按需分配最大限度地灵活利用资源，所以编译器需要进行逃逸分析确定变量放在堆上还是栈上。

查看逃逸分析过程

通过编译器命令，可以看到详细的逃逸分析过程。指令集 -gcflags 用于将标识参数传递给 Go 编译器。

• -m 会打印出逃逸分析的优化策略，最多总共可以用 4 个 -m，但是信息量较大，一般使用 1 个。

• -l 禁用函数内联，禁用掉 inline 可以更方便观察逃逸情况，减少干扰。

• go build -gcflags '-m -l' main.go

也可以通过反编译命令查看详细的逃逸分析过程。

• go tool compile -S main.go

• 可以通过 go tool compile -help 查看所有允许传递给编译器的标识参数。

逃逸案例

使用 go build -gcflags '-m -l' main.go 查看逃逸分析，这些命令适用于 linux 或 unix 环境。

package main

import "fmt"

func main()  {
	a := get()
	fmt.Println(a)
}

func get() *int{
	a := 100
	return &a
}

查看分析结果，a 分配在堆上。

laoniqiu14@ubuntu:~/gopath$ go build -gcflags '-m -l' main.go
# command-line-arguments
./main.go:11:2: moved to heap: a
./main.go:7:13: ... argument does not escape

new 创建指针

new 内置函数创建指针

• new 内置函数可以声明一个指针类型并初始化为对应类型的零值。

• new 会开辟一块内存空间，并将这块空间的内存地址返回。

• Go是强类型语言，不同类型之间不能直接进行赋值操作，指针也是具有明确类型的。

    指针名 := new(类型

new内置函数创建指针是开辟了内存空间返回给变量的，var a *int64 只是声明

• 因此 a 的值是nil（野指针），没有可用的内存空间，如果进行赋值会导致空指针异常。

• b 是有内存空间的，可以进行赋值。

package main

import "fmt"

func main() {
	var a *int64
	b := new(int32)
	fmt.Printf("a=%v,b=%v\n",a,b)
	*a = 64 // panic: runtime error: invalid memory address or nil pointer dereference
	*b = 32
	fmt.Printf("a=%v,b=%v\n",a,b)
}

new和make的区别

make 和 new 都是用来分配内存的內置函数，且在堆上分配内存。

• make 既分配内存，也初始化内存。new 只是将内存清零，并没有初始化内存。

• make内置函数只能对map、slice、channel进行内存空间分配，make返回的是引用类型本身。

• new 可以分配任意类型的内存，返回的是指向类型的指针。

指针内存示意图

func main() {
	var a int16 = 16
	p1 := &a
	p2 := &p1
	p3 := &p2
	fmt.Println("p1=",p1)
	fmt.Println("p2=",p2)
	fmt.Println("p3=",p3)
	fmt.Println("实际取值=",***p3)
	//p1= 0xc00000a0a8
	//p2= 0xc000006028
	//p3= 0xc000006030
	//实际取值= 16
}

指针内存示意图

指针内存示意图

unsafe 包

不同类型指针不允许直接相互赋值，但是Go提供了unsafe包可以实现这种操作。

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var a int32 = 32
	var b int64 = 64
	ptr := &a
	*ptr = 320
	ptr = (*int32)(unsafe.Pointer(&b))
	*ptr = 640
	fmt.Println("a=",a)
	fmt.Println("b=",b)
	fmt.Println("ptr=",*ptr)
	//a= 320
	//b= 640
	//ptr= 640
}

数组

Go中有指定长度的是数组，没有指定长度的是切片。

• 数组创建完成就是固定长度，不可追加元素。

• 数组长度是数组类型的组成部分，[2]int 和 [3]int是不同类型的。

    var 标识符 [数组程度]数组类型

• 数组定义后不初始化会是数组类型的默认值。

	var arr [2]int
	arr[0] = 100
	fmt.Println(arr)    // [100 0]

• 固定长度初始化。

    arr := [3]int{1,2,3}

• 指定数组索引初始化，索引从0开始，最后索引是len(arr) - 1。

	arr := [3]int{0:1,1:2}
	arr[len(arr)-1] = 300   // len([])获得长度，最后一个元素赋值len-1
	fmt.Println(arr)	// [1 2 300]

• 省略数组长度...初始化数组 自动推算长度。

    arr := [...]int{1,2,3,4,5}

• 数组是值类型，数组赋值或作为形参都是值拷贝。

func main() {
	var arr [2]int
	arr2 := arr
	fmt.Printf("%p\n",&arr)	// 0xc00000a0c0 
	fmt.Printf("%p\n",&arr2)	// 0xc00000a0d0 因为是值拷贝因此两个数组指向内存空间不同
}

多维数组

多维数组是数组中装数组。

• 多维数组定义只有第一维可以使用[...]推导长度。

• 多维数组访问使用索引层层确定访问的位置，ar[0][0] 访问第0组0位置元素。

• 二维数组

// 二维数组的指针是二维数组中第0组0位置地址
	ar := [...][3]int{{1,2,3},{11,22,33}}
	fmt.Println(ar)	// [[1 2 3] [11 22 33]]
	ar[0][0] = 100
	ar[0][1] = 200
	ar[1][0] = 8000
	fmt.Println(ar)	// [[100 200 3] [8000 22 33]]

• 三维数组，修改最后一个元素

	ar2 := [...][2][2]int{{{1,23},{99,556}},{{55,66},{66,88}}}
	fmt.Println(ar2) // [[[1 23] [99 556]] [[55 66] [66 88]]]
	ar2[1][1][1] = 9999999
	fmt.Println(ar2) // [[[1 23] [99 556]] [[55 66] [66 9999999]]]

slice 切片

切片是引用类型，可变长度的数组。

• 切片本质是一个结构体，内部维持一个数组array指针、长度len、容量cap。

• 内置函数len(切片)获取长度，cap(切片)获取容量。

type slice struct {
    array unsafe.Pointer
    len int
    cap int
}

• 定义、创建切片

    var 标识符 []类型    //未make()array指针 = nil，可以通过append追加元素初始化array
    标识符 := make([]类型,长度len,容量cap)
    标识符 := make([]类型,长度len)  // 不指定容量默认容量=长度

slice追加元素和扩容

切片通过append() 追加元素，如果容量不够会自动扩容，每次扩容是原容量2倍，但是最高为1024扩容。

• 切片扩容是它内部的array数组扩容，容量不够开辟一个空间更大的数组，将数组的数据拷贝到新数组再把array指针指向新的内存空间就完成扩容。

	list := make([]int,1,2)
	fmt.Println(list)	// [0]
	fmt.Println(len(list))	// 1
	fmt.Println(cap(list))	// 2
	list = append(list,3)
	list = append(list,4)
	fmt.Println(list)	// [0 3 4]
	fmt.Println(cap(list))	// 4	扩容到4 下一次到8 以此类推 直到最高以每次1024扩容

引用类型传递

引用类型传递，在函数中发生内容改变会反应到所有切片引用中。

func testSlice(sl []int)  {
	sl[0] = 999
}
func main() {
	var sl []int
	sl = append(sl,1)
	sl = append(sl,2)
	testSlice(sl)
	fmt.Println(sl)	// [999 2]
}

复制切片 copy()

	s1 := make([]int,2)
	s1[0] = 90
	s1[1] = 99
	s2 := make([]int,1)
	copy(s2,s1)
	fmt.Println(s1)	// [90 99]
	fmt.Println(s2)	// [90]

切片删除元素

切片没有提供删除元素的函数，因此删除切片的元素实际是放弃旧数组创建一个没有要被删除的元素的数组，再将 array 指向新数组。

package main

import "fmt"

func main() {
	arr := []int{1,2,3,4,5}
	//	删除开头位置 0索引位置元素1
	arr = arr[1:]
	fmt.Println(arr)	// 删除0位置元素1后： [2 3 4 5]
	//	删除中间位置的元素
	arr = append(arr[0:2],arr[3:4]...)
	fmt.Println(arr)	// 删除中间2位置元素4后：[2 3 5]
	//	删除尾部元素
	arr = arr[:len(arr)-1]
	fmt.Println(arr)	// 删除尾部元素后：[2 3]
}

数组转切片

• 数组转切片，arr[起始:结束]，arr[起始:]，arr[:结束]

	arr := [...]int{1,2,3,4,5,6,7}
	sli := arr[0:2]
	sli2 := arr[2:]
	sli3 := arr[:3]
	fmt.Println(sli)  // [1 2]
	fmt.Println(sli2) // [3 4 5 6 7]
	fmt.Println(sli3) // [1 2 3]

map 映射

map是引用类型，存储无序、不可重复（键重复覆盖）的键值对。

• map是基于键来存储值，map能够基于键快速检索数据，键就像索引一样，指向与该键关联的值。

• delete(键) 删除指定键值。

	mp := make(map[string]int)
	mp["深圳"] = 99
	mp["上海"] = 89
	mp["福州"] = 59
	fmt.Println(len(mp))	// 3
	delete(mp,"上海")
	fmt.Println(mp)	// map[深圳:99 福州:59]

• 引用类型传递，在函数中发生内容改变会反应到所有map引用中。

func testMap(mp map[int]string){
	mp[6] = "修改"
}
func main() {
	mp := make(map[int]string)
	mp[5] = "A"
	mp[6] = "B"
	mp[7] = "C"
	fmt.Println(mp)	// map[5:A 6:B 7:C]
	testMap(mp)
	fmt.Println(mp)	// map[5:A 6:修改 7:C]
}

map内部实现

map是一个集合，可以使用类似处理数组和切片的方式迭代映射中的元素。

• map是无序的集合，没有办法预测键值对被返回的顺序，即便使用同样的顺序保存键值对，每次迭代map的时候顺序也可能不一样。

• map无序的原因是map的实现使用了hash散列表。

struct 结构体

结构体可以由不同类型的元素组合，它是值类型，赋值或者作为形参都会进行值拷贝传递。

• 结构体中的类型可以是任意类型。

• 结构体的存储空间是连续的，按照声明的顺序存放。

• 匿名结构体

    func main() {
    	s := struct {
    		name string
    		age int
    	}{"小黑",99}
    	fmt.Println(s)	// {小黑 99}
    }

• 自定义结构体，结构体继承准确说是组合

    type Person struct {
    	name string
    	age int
    }
    type Stu struct {
	    Person  // 组合 Person可以匿名，也可以 字段名 Person
	    num int
    }

• 初始化

    // 按字段顺序初始化
    p := Person{"大白",99}
    // 按键值初始化
    p := Person{name:"大白",age:99}
    // 组合的字段初始化
    su := Stu{Person{"小黄",99},888}
    // 组合字段可以使用键值形式初始化，但是其本身的字段不能使用字段名初始化
    su2 := Stu{Person{name: "大尾",age: 99},888} // num:888 会无法通过编译

• new() 初始化结构体，new()返回的是一个指针

    // pn是一个指针
    pn := new(Person)
    //  标准访问成员方式 (*pn)
    (*pn).name = "大黄"
    //  编译器优化的简化访问成员方式，(*pn).成员才是标准的访问方式
    pn.age = 999

• 结构体之间进行转换

    // 两个结构体字段名、字段类型、字段个数、字段顺序要完全一样。
    type A struct{
    	Num int
    	bl bool
    }
    type B struct{
    	Num int
    	bl bool
    }
    func main() {
    	var a A
    	var b B
    	// 强制转换，可以成功，因为两个结构体字段名、字段类型、字段个数、字段顺序一样
    	a = A(b)
    	fmt.Println(a)
    }

细节

• 会进行值拷贝，p1会拷贝给p2， var p1 Person; var p2 Person = p1

• 因为值拷贝 p1与p2它们互不干扰，p1.age = 112； p2.Age = 223；

• 结构体作为函数形参也会进行值拷贝。

• 结构体在内存中是一片连续的空间。

struct 结构体 Tag

• tag可以通过反射机制获取，常用于序列化和反序列化。

• struct每个字段上都可以写多个tag使用空格间隔，也可以使用"_"忽略

• json.Marshal() json序列化读取tag为json的字段，将Name字段序列化为name。

• 零值忽略 omitempty，Class字段是零值则不会被json序列化。

type Person struct {
	Name string `json:"name" tag2:"tag2name"`
	Age int `json:"age" tag2:"tag2age"`
	Class string `json:"class,omitempty" tag2:"tag2class"`
}
func main() {
	p := Person{Name: "小尾",Age: 99}
	fmt.Println(p)	// {小尾 99}
	jsByte,_ := json.Marshal(p)
	fmt.Println(string(jsByte))	// {"name":"小尾","age":99}

	p = Person{Name: "小尾",Age: 99,Class: "一年级二班"}
	jsByte,_ = json.Marshal(p)
	fmt.Println(string(jsByte))	// {"name":"小尾","age":99,"class":"一年级二班"}
}