Golang数组与切片

数组的声明

func main() {
    var arr1 [3]int
    fmt.Println(arr1)

    var arr2 = [3]int{1, 2, 3}
    var arr3 = [...]int{1, 2, 3}

    fmt.Println(arr2, arr3)
}

[0 0 0]
[1 2 3] [1 2 3]

• Golang中的数组属于静态数组，不允许动态扩展
• Golang中数组会默认初始化值
• 可以通过[...]int{1,2,3}的方式初始化数组

数组的传值

Golang中数组与C++中的容器类似，是值而不是指针和引用

func updateArr(arr [3]int) {
    arr[0] = 100
}

func main() {
    var arr1 [3]int
    fmt.Println(arr1)

    updateArr(arr1)
    fmt.Println(arr1)
}

[0 0 0]
[0 0 0]

• Golang中的数组是值，进行赋值操作得到的是一个全新的数组
• Golang中[3]int和[4]int是不同的类型，不能相互赋值

指针传递

Golang中是支持指针

func updateArr(arr *[3]int) {
    arr[0] = 100
}

func main() {
    var arr1 [3]int
    fmt.Println(arr1)

    updateArr(&arr1)
    fmt.Println(arr1)
}

[0 0 0]
[100 0 0]

  通过指针可以进行数组的传递修改，同时和C语言不同的是对于数组指针来说不需要解引用

切片

Golang中的切片语法类似于Python，但是底层实现迥然不通

func updateArr(arr []int) {
    arr[0] = 100
}

func main() {
    var arr1 [3]int
    fmt.Println(arr1)

    updateArr(arr1[:])
    fmt.Println(arr1)
}

[0 0 0]
[100 0 0]

  Golang中的切片可以得到类似引用的效果，[]int在Golang中指代的是引用类型

Golang中的数组切片

---

  Golang中的切片结构包括三部分，①指向底层数据结构数组的指针，使用该指针修改数组；②长度，即切片的长度；③切片的容量，切片的容量包括切片的长度和数组中在切片后的元素。

func main() {
    var arr1 = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(arr1)

    sli1 := arr1[2:8]
    fmt.Println(sli1, len(sli1), cap(sli1))
    fmt.Println("slice [6]: ", sli1[6])
}

[0 1 2 3 4 5 6 7 8 9]
[2 3 4 5 6 7] 6 8
panic: runtime error: index out of range [6] with length 6

goroutine 1 [running]:
main.main()
    c:/Users/zhangyu/Go/src/study/main.go:34 +0x21e
Process exiting with code: 2 signal: false

  虽然切片的容量包括切片后的元素，但是访问报错

向切片添加元素

func main() {
    var arr1 = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(arr1)

    sli1 := arr1[2:8]
    fmt.Println(sli1, len(sli1), cap(sli1))

    sli2 := append(sli1, 10)
    fmt.Println("sli2 [6]: ", sli2[6])

    sli3 := sli1[6:7]
    fmt.Println("sli3: ", sli3)

    fmt.Println("arr1: ", arr1)
}

[0 1 2 3 4 5 6 7 8 9]
[2 3 4 5 6 7] 6 8
sli2 [6]:  10
sli3:  [10]
arr1:  [0 1 2 3 4 5 6 7 10 9]

• 切片可以追加元素，追加的元素会覆盖到原有的数组上去
• 再切片上再次切片，可以获得切片后的元素

append越界了会怎么样?

func main() {
    var arr1 = [...]int{0, 1, 2, 3}
    var sli1 = arr1[2:3:3]

    sli1 = append(sli1, 4)
    fmt.Println(arr1, sli1)
}

[0 1 2 3] [2 4]

  添加元素超过cap后会创建一个新的数组，与原数组无关了