Go语言基础之复合类型

• 分类：指针（pointer)、数组(arry)、切片(slice)、字典(map)、结构体(struct)

一、指针

1. 基本操作

• 默认值nil， 没有NULL常量
• 操作符"&"取变量地址
• "*"通过指针访问目标对象
  • 保存某个变量的地址，需要指针类型
  • *int保存int的地址
• 不支持指针运算，不支持"->"运算符
• 直接用“.”访问目标成员
• 不能操作没有合法指向的内存

2. new函数

func main() {
    var p1 *int
    p1 = new(int) //p1为*int 类型, 指向匿名的int变量
    fmt.Println("*p1 = ", *p1) //*p1 =  0

    p2 := new(int) //p2为*int 类型, 指向匿名的int变量
    *p2 = 111
    fmt.Println("*p2 = ", *p2) //*p1 =  111
}

3. 指针做函数参数

func swap01(a, b int) {
    a, b = b, a
    fmt.Printf("swap01 a = %d, b = %d\n", a, b)
}

func swap02(x, y *int) {
    *x, *y = *y, *x
}

func main() {
    a := 10
    b := 20

    //swap01(a, b) //值传递
    swap02(&a, &b) //变量地址传递
    fmt.Printf("a = %d, b = %d\n", a, b)
}

二、数组

1. 定义数组

var a [10]int // 定义一个有10个数的数组
var a [2]int = [2]int{1, 2, 3}
b := [3]int{1, 2, 3, 4}

• 没有初始化的元素，自动赋值为0

• 指定某个元素值

  c := [3]int{1:111, 2:222} //下标为1的值为111

• 获取数组长度：len()、cap()容量

2. 二维数组

• 初始化二维数组

  b := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
  

3. 数组比较和赋值

• 数组支持比较
• 同类型的数组可以赋值

4. 随机数

package main

import "math/rand"

func main() {
	rand.Seed(123)  // 设置种子参数，参数一样，获取到的随机数一样
	rand.Int()  // 随机获取一个很大的数
	rand.Intn(100)  //限制随机数范围
} 

5. 排序

• 冒泡排序

三、切片（slice）

• slice并不是真正意义上的动态数组，而是一个引用类型。
• slice总是指向一个底层array
• slice的声明也可以像array一样，只是不需要长度

1. 切片和数组的区别

• 数组[]里的长度是固定的一个常量，数组不能修改长度
• 声明slice时，方括号内没有任何字符。

2. 切片的操作

• array := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

操作	结果	len	cap	说明
array[:6:8]	[0 1 2 3 4 5]	6	8	省略 low
array[5:]	[5 6 7 8 9]	5	5	省略 high、 max
array[:3]	[0 1 2]	3	10	省略 high、 max
array[:]	[0 1 2 3 4 5 6 7 8 9]	10	10	全部省略

3. 内建函数

1. append

• 向切片尾部添加数据
• 一旦超过原底层数组容量，通常以2倍容量重新分配底层数组，并复制原来的数据

2. copy

• 在两个 slice 间复制数据，复制⻓度以 len 小的为准，两个 slice 可指向同⼀底层数组

四. map

• map里所有键的数据类型必须是相同的，值也必须如何
• 键和值的数据类型可以不相同
• map是无序的

1. 创建和初始化

1) 创建

var m1 map[int]string //只是声明一个map，没有初始化, 此为空(nil)map
m2 := map[int]string{}
m3 := make(map[int]string)
m4 := make(map[int]string, 10) //第2个参数指定容量

2) 初始化

//1、定义同时初始化
var m1 map[int]string = map[int]string{1: "mike", 2: "yoyo"}
fmt.Println(m1) //map[1:mike 2:yoyo]

//2、自动推导类型 :=
m2 := map[int]string{1: "mike", 2: "yoyo"}
fmt.Println(m2)

2. 常用操作

1. 遍历

• 迭代遍历，第一个返回值是key，第二个返回值是value

2. 删除

delete(m1, 2) // //删除key值为3的map

3. map做函数参数

• 在函数间传递映射并不会制造出该映射的一个副本，不是值传递，而是引用传递

五、结构体

• 结构体是一种聚合的数据类型
• 它是由一系列具有相同类型或不同类型的数据构成的数据集合。
• 每个数据称为结构体的成员
• p.成员 和(*p).成员 操作是等价的
• 结构体是可以比较的，两个结构体将可以使用 == 或 != 运算符进行比较，但不支持 > 或 <

可见性

• 要使某个符号对其他包（package）可见（即可以访问），需要将该符号定义为以大字母开头