c语言数组切片,Go 其二 数组与切片

艺多不压身，学习一下最近蛮火的Go语言，整理一下笔记。相关Code和笔记也放到了Git上，传送门。

数组的声明

var a [3] int //声明并初始化为默认零值

a[0] = 1

b := [3]int{1,2,3} //声明同时初始化

c := [2][2]int{{1,2},{3,4}} //多维数组初始化

Go语言中定义的变量一定要使用，否则会报错，但如果只是想使用foreach的写法，可以使用 _ 来占位.

//foreach的写法, idx即为数组的索引的值

for idx, e:= range arr2 {

t.Log(idx, e)

}

//Go语言中定义的变量一定要使用，所以下面的写法会报错 idx declared but not used

// for idx, e:= range arr2 {

// t.Log(e)

// }

//如果只是想使用foreach的写法，可以使用 _ 来占位

for _, e:= range arr2 {

t.Log(e)

}

数组截取

a[开始索引(包含)， 结束索引(不包含)]

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

a[1:2] // 2

a[1:3] // 2,3

a[1:len(1)] // 2, 3, 4, 5

a[1:] //2, 3, 4, 5 //从索引1开始一直到末尾

a[:3] //1,2,3 //从索引0开始，一直到索引为3的位置，不包含索引为3的值

---------------------------------------------------------------

切片

切片在别的语言中不一定有，比如c#

使用起来像是可变长数组

切片内部结构

实际上是一个结构体，包含三个元素

1.指针，指向一片连续的存储空间(一个数组)ptr

2.切片内的元素个数 len

3.指针指向的这个数组的长度，容量 cap

//与声明数组很类似，区别是没有指定长度！例如

var s0 []int

利用len()方法来获得切片内元素个数

利用cap()方法来获得切片空间大小

利用append(s0, 1)来填充切片

使用make方法来声明长度和容量不同的切片 例如

//这里s2长度为3，但容量为5

s2 := make([]int, 3, 5)

其中len个元素会被初始化为默认值0，未初始化元素不可访问

切片本质上是共享的存储结构,注意这里的共享指的是由同一个切片“派生”出的其他切片或数组，例如

year := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}

q2 := year[3:6]

summer := year[5:8]

year,q2,summer是共享存储空间的

而反之，如

a := []int{1,2,3,4}

b := []int{1,2,3,4}

虽然初始的值相同，但其实是不共享存储空间的

---------------------------------------------------------------

数组 VS 切片

1. 容量是否可以伸缩，数组不可以，切片可以

2. 是否可以进行比较，数组可以与数组比较，切片与切片之间不可以比较

附录：

数组相关Code:

package array_test

import "testing"

func TestArrayInit(t *testing.T){

var arr [3]int

t.Log(arr[1],arr[2])

arr1 := [4]int{1,2,3,4}

//不指定长度且初始化时可以用[...]

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

arr1[1] = 9

t.Log(arr1[1], arr1[3])

t.Log(arr2[2])

}

func TestArrayTraval(t *testing.T){

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

for i:= 0; i < len(arr2); i++{

t.Log(arr2[i])

}

//foreach的写法, idx即为数组的索引的值

for idx, e:= range arr2 {

t.Log(idx, e)

}

//Go语言中定义的变量一定要使用，所以下面的写法会报错 idx declared but not used

// for idx, e:= range arr2 {

// t.Log(e)

// }

//如果只是想使用foreach的写法，可以使用 _ 来占位

for _, e:= range arr2 {

t.Log(e)

}

}

func TestArraySection(t *testing.T){

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

arr3_sec := arr3[:3]

t.Log(arr3_sec)

arr3_sec2 := arr3[3:]

t.Log(arr3_sec2)

}

切片相关code:

package slice_test

import "testing"

func TestSliceInit(t *testing.T){

//与声明数组很类似，区别是没有指定长度！

var s0 []int

t.Log(len(s0), cap(s0))

s0 = append(s0, 1)

t.Log(len(s0), cap(s0))

//初始化

s1 := []int{1,2,3,4}

t.Log(len(s1), cap(s1))

//这里s2长度为3，但容量为5

s2 := make([]int, 3, 5)

t.Log(len(s2), cap(s2))

//这里会报错，因为后两个元素会越界

//t.Log(s2[0],s2[1],s2[2],s2[3],s2[4])

t.Log(s2[0],s2[1],s2[2])

s2 = append(s2, 1)

t.Log(s2[0],s2[1],s2[2],s2[3])

}

func TestSliceGrowing(t *testing.T){

s:=[]int{}

for i:=0; i<10; i++{

s = append(s, i)

t.Log(len(s), cap(s))

}

//输出结果

/*

TestSliceGrowing: slice_test.go:30: 1 1

TestSliceGrowing: slice_test.go:30: 2 2

TestSliceGrowing: slice_test.go:30: 3 4

TestSliceGrowing: slice_test.go:30: 4 4

TestSliceGrowing: slice_test.go:30: 5 8

TestSliceGrowing: slice_test.go:30: 6 8

TestSliceGrowing: slice_test.go:30: 7 8

TestSliceGrowing: slice_test.go:30: 8 8

TestSliceGrowing: slice_test.go:30: 9 16

TestSliceGrowing: slice_test.go:30: 10 16

*/

//每次不够放的适合，都会将上次的扩展为之前的两倍，因此要使用类似于s2 = append(s2, 1) 因为是新的空间给s2，并将原来的数据拷贝过去。

}

func TestSliceShareMemory(t *testing.T) {

year := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}

q2 := year[3:6]

t.Log(q2, len(q2), cap(q2))

//输出结果为

//TestSliceShareMemory: slice_test.go:53: [Apr May Jun] 3 9,容量是直接到末尾的，所以是9.

summer := year[5:8]

t.Log(summer, len(summer), cap(summer))

summer[0] = "Unkonw"

t.Log(summer, len(summer), cap(summer))

t.Log(q2, len(q2), cap(q2))

//输出结果为

/*

TestSliceShareMemory: slice_test.go:60: [Unkonw Jul Aug] 3 7

TestSliceShareMemory: slice_test.go:61: [Apr May Unkonw] 3 9

*/

//由于是共享的存储空间，因此summer的改动同时影响到了q2的值.

}

func TestSliceComparing(t *testing.T){

a := []int{1,2,3,4}

b := []int{1,2,3,4}

//会报错，nvalid operation: a == b (slice can only be compared to nil)

// if(a == b){

// t.Log("Can Compare")

// }

t.Log(a[2])

t.Log(b[2])

b[2] = 9

t.Log(a[2])

t.Log(b[2])

}