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\n", &x)
   x[1] = 100
}

func main() {
   a := [2]int{}
   fmt.Printf("a: %p\n", &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]#