go——数组

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

1	`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]
*/