go——数组

数组（array）就是由若干个相同类型的元素组成的序列。

var ipv4 [4]uint8 = [4]uint8(192,168,0,1)

在这条赋值语句中，我们为刚声明的变量ipv4赋值。在这种情况下，变量名右边的类型字面量可以省略。
如果它在函数里面，那么关键字var也可以省略，但赋值符号必须由=变为:=。

类型字面量[4]uint8表明这个变量的类型长度为4且元素类型为uint的数组类型。
注意，数组的长度是数组类型的一部分。
只要类型声明中的数组长度不同，即两个数组类型的元素类型相同，它们也是不同的类型。
更重要的是，一旦在声明中确定了数组类型的长度，就无法改变它了。
同时，同一类型的数组可以使用操作符==、！=。

package main

import "fmt"

var d0 [2]int //d0是数组类型的变量，因此也要遵循变量使用原则，全局变量可以只定义不使用，但是局部变量不行。

func main() {
	var d1 [3]int
	var d2 [2]int
	fmt.Println(d1 == d2) //invalid operation: d1 == d2 (mismatched types [3]int and [2]int)长度不同

	d3 := [2]int{1, 2}
	d4 := [2]int{2, 3}
	fmt.Println(d3 != d4) //true

}

数组初始化的方式比较灵活。
数组类型的零值一定是一个不包含任何元素的空数组。
一个类型的零值即为该类型变量未被显式赋值时的默认值。

package main

import "fmt"

func main() {
	var a [3]int

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

	c := [4]int{5, 3: 10}

	d := [...]int{1, 2, 3}

	e := [...]int{3, 4, 4: 9}

	fmt.Println(a) //[0 0 0]      int类型的元素默认值为0
	fmt.Println(b) //[2 3 0 0]    位提供初始化的元素自动使用默认值
	fmt.Println(c) //[5 0 0 10]   3：10表示元素10是数组的第4个元素
	fmt.Println(d) //[1 2 3]      省略长度，但不是没有，编译器按照初始化元素的数量确定长度
	fmt.Println(e) //[3 4 0 0 9]

}

对于结构等复杂类型，可省略元素初始化类型标签。

package main

import "fmt"

func main() {
	type user struct {
		name string
		age  int
	}

	d := [...]user{
		{"kebi", 26},    //省略类型标签
		{"maoxian", 24},
	}

	fmt.Println(d)  //[{kebi 26} {maoxian 24}]
}

在定义多维数组时，仅第一维数组可以使用"..."。
内置函数len和cap都只能返回第一维度的长度。

package main

import "fmt"

func main() {
	a := [2][3]int{
		{1, 2, 3},
		{4, 5},
	}

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

	fmt.Println(a, len(a), cap(a))
	fmt.Println(b, len(b), cap(b))
}

/*
[[1 2 3] [4 5 0]] 2 2
[[4 2] [3 4]] 2 2
*/

要注意区分指针数组和数组指针。
指针数组：元素为指针类型的数组；数组指针：获取数组变量的指针。

package main

import "fmt"

func main() {
	a := [...]int{1, 2, 3}
	fmt.Println(&a)           //数组没有指针，只有数组的元素才有指针,数组只是对底层元素的包装
	fmt.Println(&a[0], &a[1]) //数组指针 0xc00004c0c0 0xc00004c0c8

	x, y := 10, 20
	b := [2]*int{&x, &y}  //指针数组
	fmt.Println(b)  [0xc00004c0c0 0xc00004c0c8]
}

通过指针可以反取数据。

package main

import "fmt"

func main() {
	a := [2]int{1, 2}
	p := &a
	fmt.Println(*p) //[1 2]
}

Go数组是值类型，复制和传参都会复制整个数组。
数组的指针是数组中第一个元素的指针。
数组是内层中某个连续的片段，复制和赋值都会在此分配片段，这属于值复制，指针也不同。

package main

import "fmt"

func test(x [2]int) {
	fmt.Printf("x: %p, %v\n", &x, x)
}

func main() {
	a := [2]int{10, 20}
	var b [2]int
	b = a //复制

	fmt.Printf("a: %p, %v\n", &a, a) //a: 0xc00004e080, [10 20]
	fmt.Printf("b: %p, %v\n", &b, b) //b: 0xc00004e090, [10 20]
	test(a)                          //传参//x: 0xc00004e0f0, [10 20]
	fmt.Println(&a[0], &a[1])        //0xc00004e080 0xc00004e088
	fmt.Println(&b[0], &b[1])        //0xc00004e090 0xc00004e098
}

如果需要，可改用指针或切片，这样就可以避免复制，以此可以减少资源的消耗。

package main

import "fmt"

func test(x *[2]int) {
	fmt.Printf("x: %p, %v\n", x, *x)
}

func main() {
	a := [2]int{10, 20}
	test(&a)  //直接传递的是指针，这样就避免复制

	fmt.Printf("a: %p, %v\n", &a, a)
}

/*
x: 0xc00004e080, [10 20]
a: 0xc00004e080, [10 20]
*/

当需要详细规划程序所用的内存时，数组类型非常有用。
使用数组值可以完全避免耗时费力的内存二次分配操作，因为它的长度是不可改变的。