Go 定长的数组

1.Go 语言数组的简介

   几乎所有的计算机语言都有数组，应用非常的广泛。同样，在 Go 语言中也有数组并且在数组的基础上还衍生出了切片(slice)。

数组是一系列同一类型数据的集合，数组中包含的每个数据被称为数组元素，一个数组包含的元素个数被称为数组的长度，这是

数组的基本定义。

   在 Go 语言中数组是一个值类型(Value Type)。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。如果数组作

为函数的参数类型，在调用函数时该参数将发生数据复制。因此，函数体内无法修改传入的数组的内容。因为函数内操作的只是所

传入数组的一个副本。

 2.数组定义

定义方式

var arr [n]type

    arr 表示数组名称，n 表示数组长度，type 表示数组元素类型

    在 Go 语言中，数组长度在定义后就不能更改，所以，在声明时长度可以作为一个常量或常量表达式，数组长度也是判断两个数组是否

相等的一个标准，如果两个数组长度不相等，则这两个数组也是不相等的。Go 语言中使用函数 len() 计算数组长度。

3.数组声明及初始化

  声明

var a [5]int //长度为5的数组，每个元素为一个int
var b [2*N] struct { x, y int5 } //复杂类型数组(数组类型为struct)
var c [5]*int // 指针数组
var d [2][3]int //二维数组 go 支持多维数组

 初始化

a = {1,2,3}
d = {{1,2,3},{4,5,6}} 

声明并初始化

a := [3]int{1, 2, 3} //声明并初始化一个长度为3的int数组
a := [...]int{1, 2, 3} //可以省略长度而采用`...`的方式，Go会自动根据元素个数来计算长度
d := [2][3]int{[3]int{1,2,3},[3]int{4,5,6}}
d := [2][3]int{{1,2,3},{4,5,6}} //如果内部的元素和外部的一样，那么上面的声明可以简化，直接忽略内部的类型

4.数组访问

  可以使用数组下标访问数组中的元素，数组下标是从 0 开始，一个数组最后一个元素的下标是 len(arr) - 1。

  计算数组长度(使用 go 内置函数 len())

  例如

package main

import(
"fmt"
)

func main(){
    arr := [...]int {9: 1}
    fmt.Println(arr)
    fmt.Println(len(arr))
}

输出结果

[root@VM_81_181_centos golang]# go run test.go 
[0 0 0 0 0 0 0 0 0 1]
10
[root@VM_81_181_centos golang]# 

使用 for 循环访问

package main

import "fmt"

func main() {
   arr := [...]int{9:1}

   for i := 0;i < len(arr);i++ {
      fmt.Println(arr[i])
   }
}

输出结果

[root@VM_81_181_centos golang]# go run test.go 
0
0
0
0
0
0
0
0
0
1
[root@VM_81_181_centos golang]# 

通过 range 访问

package main

import "fmt"

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

   for i,v := range arr {
      fmt.Println(i,v)
   }
}

输出结果

[root@VM_81_181_centos golang]# go run test.go 
0 1
1 2
2 3
3 4
4 5
[root@VM_81_181_centos golang]# 

range  具有两个返回值，第一个返回值 i 是数组元素的下标，第二个返回值 v 是元素的值

5.数组值拷贝

package main

import "fmt"

func test(x [2]int) {
   fmt.Printf("x: %p
", &x)
   x[1] = 100
}

func main() {
   a := [2]int{}
   fmt.Printf("a: %p
", &a)

   test(a)
   fmt.Println(a)
}

输出结果

[root@VM_81_181_centos golang]# go run test.go 
a: 0xc42000a2e0
x: 0xc42000a310
[0 0]
[root@VM_81_181_centos golang]# 

我们可以看到数组 a 的值并没有被改变

6.数组指针(*[n]T)和指针数组([n]*T)

  区别这两个还是需要看星号(*)和谁结合，如：var p *[n]int，星号(*)和数组结合则是数组指针，如：var p [n]*int，星号(*)和int

结合，说明这个数组都是 int 类型的指针，是指针数组。

  结合具体的程序看一下

package main

import "fmt"

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

   for index, value := range *p{
       fmt.Println(index, value)
   }

   var p2 [5]*int
   i,j := 10,20
   p2[0] = &i
   p2[1] = &j
   for index,value := range p2 {
       if(value != nil) {
          fmt.Println(index, *value)
       } else {
          fmt.Println(index, value)
       }
   }
}

输出结果

[root@VM_81_181_centos golang]# go run test.go 
[1 2 3 4 5] [1 2 3 4 5]
0 1
1 2
2 3
3 4
4 5
0 10
1 20
2 <nil>
3 <nil>
4 <nil>
[root@VM_81_181_centos golang]#