Golang基础学习项目地址：

概述

golang中的数组与其他一些语言中的数组，不同点在于：golang中的数组是值类型，并非是基础数据类型，这一点很重要。 可以使用指针来对数组进行引用传递。 数组初始化之后，长度确定，每个元素的值为数组类型的默认值。 数组的地址与数组的第一个元素的地址一致。 除数组第一个元素外的其他元素的地址=前一个元素的地址+数组类型所占用的字节数，即数组中的元素地址是连续的。

所以当我们使用print打印数组的时候，数组的第一个元素地址即可代表该数组的地址，根据第一个元素的地址，可以得出之后每一个元素的地址，便可以打印出数组中每一个元素的值。

示例

package main

import "fmt"

//Golang中的数组是值类型，并非是基本数据类型
var array [10]int
var array2 = [3]int{1, 2, 3}
var array3 = [...]int{2, 3, 4}        //让编译器推断数组的长度
var array4 = [4]int{0: 1, 1: 3, 2: 4} //指定下标进行赋值

func main() {
	//数组初始化之后，长度确定，每个元素的默认值为数组类型的默认值
	fmt.Printf("array=%v,length:%d
", array, len(array))
	//数组的地址与数组的第一个元素的地址一致
	fmt.Printf("array的地址为%p
", &array)
	fmt.Printf("array[0]的地址为%p
", &array[0])
	//除数组第一个元素外的其他元素的地址=前一个元素的地址+数组类型所占用的字节数
	for i := 0; i < len(array); i++ {
		array[i] = i + 1
		fmt.Printf("array[%d]的地址=%p
", i, &array[i])
	}
	fmt.Printf("array=%v,length:%d
", array, len(array))
	fmt.Printf("array的地址为%p
", &array)

	//数组的遍历
	array5 := [...]int{0: 1, 1: 5, 3: 4}
	for i := 0; i < len(array5); i++ {
		fmt.Printf("array5[%d]=%d
", i, array5[i])
	}
	for idx, element := range array5 {
		fmt.Printf("array5[%d]=%d
", idx, element)
	}

	//组数在golang中是基本数据类型，是值传递
	array6 := [...]int{1, 2, 3, 4}
	fmt.Printf("调用changeArray1前，array6=%v
", array6)
	changeArray1(array6)
	fmt.Printf("调用changeArray1后，array6=%v
", array6)
	//如果想要使用引用传递的方式传递数组变量，请使用指针
	fmt.Printf("调用changeArray2前，array6=%v
", array6)
	changeArray2(&array6)
	fmt.Printf("调用changeArray2后，array6=%v
", array6)
}

//由于组数在golang中是基本数据类型，是值传递，并非引用传递，所以该方法无法修改元数据array6的值
func changeArray1(array [4]int) {
	array[0] = 7
	fmt.Printf("changeArray1中array=%v
", array)
}

//使用指针对数组进行引用传递
func changeArray2(array *[4]int) {
	array[0] = 8
	fmt.Printf("changeArray2中array=%v
", array)
}

二维数组

package main

import "fmt"

//二维数组声明
var tda1 [3][3]int

//二维数组的声明并初始化
var tda2 [2][2]int = [2][2]int{
         
  {1, 2}, {3, 4}}

//推断数组长度
var tda3 [2][2]int = [...][2]int{
         
  {1, 2}, {3, 4}}
var tda4 [2][...]int = [...][...]int{
         
  {1, 2}, {3, 4}}
var tda5 [3][...]int = [3][...]int{
         
  {1, 2}, {3, 4}}
var tda6 [3][...]int = [...][...]int{
         
  {1, 2}, {3, 4}, {}}

//推断类型
var tda7 = [...][...]int{
         
  {1, 2}, {3, 4}, {}}

func main() {
	fmt.Printf("与其他语言的二维数组一样，属于是一个数组的元素为数组类型,tda1=%v
", tda1)
	//将左上角到右下角这条线上的数字赋值为1
	for i := 0; i < len(tda1); i++ {
		tda1[i][i] = 1
	}
	//输出二维数组
	for _, e := range tda1 {
		for idx, a := range e {
			if idx == len(e)-1 {
				fmt.Println(a)
			} else {
				fmt.Print(a, " ")
			}
		}
	}

	//二位数组的内存布局
	//二位数组中，每个元素的地址为一个一维数组的地址，且地址是连续的，这个地址同时是这个一维数组第一个元素的地址
	fmt.Printf("tda1[0] address=%p
", &tda1[0]) // &tda1[0] = &(tda1[0])
	fmt.Printf("tda1[1] address=%p
", &(tda1[1]))
	fmt.Printf("tda1[0][0] address=%p
", &tda1[0][0])
	fmt.Printf("tda1[1][0] address=%p
", &(tda1[1][0]))
}