Go学习-数组

数组初始化

package main

import (
	"fmt"
)

func main() {
	//定长,没有初始值
	a := [2]int{}
	//定长定义初始值
	b := [2]int{1, 2}
	//不定长具有初始值
	c := [...]int{1, 2}
	//new得到数组引用
	d := new([2]int)
	fmt.Println(a, b, c, d)
}

运行结果

chenlilong@DESKTOP-B9ALUUJ MINGW64 /d/gopath/src
$ go run main.go
[0 0] [1 2] [1 2] &[0 0]

数组的注意事项

1、定长数组初始化，不一定初始化所有值，未被初始化的值，使用默认值代替（如int使用0）

2、可以使用下标的方式进行初始化

3、不定长数组是要用... ,注意区别数组与slice的不定长区别（数组和slice的内存结构不一样）

4、new初始化数组的是引用，但是仍然可以用下标进行赋值

5、new初始化的数组必须指定长度，也不定进行赋值

6、数组的可以进行==比较，比较类型与长度，不是比较地址

7、数组的传递是值传递

8、可以使用range遍历（注意值传递）

9、长度和类型是数组的一部分，不同长度和不同类型不能进行比较，例如[2]int{} 不能和 [3]int{3}

10、数组初始化以后就是定长的,例如 [...]int{0,0} 可以和 [2]int{0,0} 比较

11、可以使用len 和 cap

package main


import (
	"fmt"
)


func main() {
	//默认值
	a := [3]int{1}
	//使用下标方式初始化
	b := [3]int{1: 1}
	//区别slice
	c1 := [...]int{1, 2, 3} //这是不定长数组
	c2 := []int{1, 2, 3}    //这是slice
	//new
	d := new([2]int)
	d[0] = 1
	// d := new([2]int{1,2})
	// d := new([...]int{0,0})
	fmt.Println(a, b, c1, c2, d)


	//数组的比较
	e1 := [2]int{}
	e2 := [...]int{0, 0}
	fmt.Println(e1 == e2)


	//数组的值传递
	f1 := [2]int{}
	var f2 = f1
	fmt.Println(f1 == f2)
	f1[0] = 1
	fmt.Println(f1, f2)
	fmt.Println(f1 == f2)


	//可以使用len，cap
	fmt.Println(len(a), cap(a))


	//比较
	g1 := [...]int{0, 0}
	g2 := [2]int{0, 0}
	fmt.Println(g1 == g2)
}

运行结果

chenlilong@DESKTOP-B9ALUUJ MINGW64 /d/gopath/src
$ go run main.go
[1 0 0] [0 1 0] [1 2 3] [1 2 3] &[1 0]
true
true
[1 0] [0 0]
false
3 3
true