GO-数组

package ch4





func main(){

	/**
		1.声明数组
	*/
	// 声明数组时需要指定内部存储的数据的类型，
	// 以及需要存储的元素的数量，元素默认为零值
	// 声明一个包含5个元素的整型数组
	var array [5]int


	// 使用数组字面量快速创建数组
	array := [5]int {1, 2, 3, 4, 5}

	// 使用...代替数组的长度，初始化时系统自动确认
	array := [...]int {1, 2, 3, 4, 5}

	// 声明数组并指定特定元素的值
	array := [5]int {1:10, 2:20}


	/**
		2.使用数组
	*/

	// 修改索引为2的元素的值
	array ;= [5]int {10, 20, 30, 40, 50}
	array[2] = 35 

	// 声明包含5个元素的指向整数的数组
	// 用整型指针初始化索引为0和1的数组元素
	array := [5]*int {0:new(int), 1:new(int)}
	// 为索引为0和1的元素赋值
	*array[0] = 10
	*array[1] = 20

	// 数组变量的类型包括数组长度和每个元素的类型。只有这两部分都相同的数组，
	// 才是类型相同的数组，才能互相赋值。
	// 声明第一个包含5个元素的字符串数组
	var array1 [5]string
	// 声明第二个包含5个元素的字符串数组
	// 用颜色初始化数组
	array2 := [5]string{"red", "blue", "green", "yellow", "pink"}
	// 把array复制到array1
	// 复制之后，两个数组完全一样
	array1 = array2

	// 把一个指针数组复制给另一个
	// 声明第一个包含3个元素的指向字符串的指针数组
	var array1 [3]*string
	// 声明第二个包含3个元素的指向字符串的指针数组
	// 使用字符串指针初始化这个数组
	array2 := [3]*string{new(string), new(string), new(string)}
	// 使用颜色为每个元素复制
	*array2[0] = "red"
	*array2[1] = "blue"
	*array2[2] = "green"
	// 将array2复制给array1
	array1 = array2


	/*
		多维数组
	*/
	// 声明二维数组
	// 声明一个二维整型数组，两个维度分别存储4个元素和2个元素
	var array [4][2]int
	// 使用数组字面量来声明并初始化一个二维整型数组
	array := [4][2]int {{10, 11}, {20, 21}, {30, 31}, {40, 41}}
	// 声明并初始化外侧呢个数组中索引为1和3的元素
	array := [4][2]int {1:{20, 21}, 3:{40, 41}}
	// 声明并初始化外层数组和内层数组的单个元素
	array := [4][2]int {1:{0:20}, 3:{1: 41}}

	// 访问二维数组
	// 声明一个2*2的二维整型数组
	var array [2][2]int
	// 设置每个元素的整型值
	array[0][0] = 10
	array[0][1] = 20
	array[1][0] = 30
	array[1][1] = 40
	
	// 同样类型的多维数组赋值
	// 声明两个不同的二维整型数组
	var array1 [2][2]int
	var array2 [2][2]int
	// 为每个元素赋值
	array2[0][0] = 10
	array2[0][1] = 20
	array2[1][0] = 30
	array2[1][1] = 40
	// 将array2的值复制给array1
	array1 = array2

	// 使用索引为多维数组复制
	// 将array1的索引为1的维度复制到一个同类型的新数组里
	var array3 [2]int = array1[1]
	// 将外层数组的索引为1、内层数组的索引为0的整型值复制到新的整型变量里
	var value int = array1[1][0]


	/*
		在含函数间传递数组
	*/
	// 使用值传递，在函数间传递大数组
	// 声明一个需要8MB的数组
	var array[le6]int
	// 将数组传递给函数foo
	// 每次调用foo时，必须在栈上分配8MB的内存，用指针进行引用传递的方式更好
	foo(array)

	// 使用指针在函数间传递大数组
	// 声明一个需要8MB的数组
	var array [le6]int
	// 将数组的地址传递给函数foo
	// 只需要在栈上分配8字节的内存就可以
	foo(&array)


}


// 函数foo接受一个100万个整型值的数组
func foo(array [le6]int){

}


// 接受一个指向100万个整型值的数组的指针
func foo(array *[le6]int)  {
	
}