var a [3]int	// a是长度为3的数组，内容为0
var b = [3]int{1, 2, 3}
c := [3]int{1,2,3}

由于数组只需要内部元素有着相同类型，所以自然地衍生出一个问题：数组是否可以作为另一个数组的元素？此即二维数组。下面列举几个二维数组初始化的案例

a := [3][2]int{  
 {0, 1},
 {2, 3},
 {4, 5}, 
}
b := [3][2]int{  
 {0, 1},
 {2, 3},
 {4, 5}}
c := [3][2]int{{0, 1},  {2, 3},  {4, 5}}

b和a完全相同，只是最后一行少了个逗号，所以必须把最后一个花括号挪上去。

下面做一个测试

// arr.go
package main
import "fmt"
func arrTest1(){
	c := [3][2]int{{0, 1},  {2, 3},  {4, 5}}
	for i,r := range c{
		for j,x := range r{
			fmt.Println("c[",i,"][",j,"]=",x)
		}
	}
}
func main(){
	arrTest1()
}

结果如下

>go run arr.go
c[ 0 ][ 0 ]= 0
c[ 0 ][ 1 ]= 1
c[ 1 ][ 0 ]= 2
c[ 1 ][ 1 ]= 3
c[ 2 ][ 0 ]= 4
c[ 2 ][ 1 ]= 5

理论上数组的维度是可以不断递增的，比如下面的代码可以初始化一段2×3×42\\×3×4的数组

var triArr1 [2][3][4] int
triArr2 := [2][3][4] int

切片

在go语言中，数组元素是固定的，因此实际使用时会受到许多限制。相比之下，切片更加强大而易用。

就写法来说，只要声明一个未定义长度的数组，即表示新建并初始化了一个切片。据说在生成并初始化一个切片的同时，也会默认生成一个长度固定的数组。而且这个数组还会影响切片的长度。通过关键字make可以声明一个定义了最大长度的切片。

func slTest()  {
	sl1 := []int{1,2,3,4,5}
	fmt.Println("sl1=",sl1)
	fmt.Println("sl1[1:4]=",sl1[1:4])	//slice索引
	fmt.Println("sl1[1:4]=",sl1[:4])	//左端默认为0，右端默认为切片长度
	var sl2 = make([]int,3,5)
	fmt.Printf("len=%d cap=%d slice=%v\n", len(sl2),cap(sl2),sl2)
}

其中，len()返回切片长度；cap()返回切片的最大长度，运行结果如下

>go run arr.go
sl1= [1 2 3 4 5]
sl1[1:4]= [2 3 4]
sl1[1:4]= [1 2 3 4]
len=3 cap=5 slice=[0 0 0]

指针

支持数组这个并不稀奇，但凡有一点野心的编程语言，都会支持数组。但指针就太让人意外了，这种几乎只在C语言中出现的古老工具，竟然出现再了如此年轻的go语言身上，可能ken就好这口吧。

和C语言类似，定义指针需用到*，指向某个内存地址，其取地址符为&，示例如下

func ptrTest(){
	var arr [5]int			//声明一个长度为5的数组
	for i := 0; i<5; i++{
		arr[i] = i*i
		fmt.Printf("第 %d 位赋值为 %d \n",i,arr[i])
	}
	var ip *int
	var fp *float64
	ip = &arr[0]	//将ip指向arr[0]的地址
	fmt.Printf("fp的值为：%x\n",fp)	//由于fp未赋值，所以为空指针
	fmt.Printf("ip的值为：%x\n",ip)
}

其中，ip是一个整型指针，fp是一个浮点型指针，

运行结果如下

>go run arr.go
第 0 位赋值为 0
第 1 位赋值为 1
第 2 位赋值为 4
第 3 位赋值为 9
第 4 位赋值为 16
fp的值为：0
ip的值为：c000012480