葡萄美酒夜光杯

zhltom

// 声明一个包含5个元素的整型数组　　
// 一旦声明，数组里存储的数据类型和数组长度就都不能改变
　　
var array [5]int                //数组默认值为0
　　
array := [5]int{10, 20, 30, 40, 50}
　　
array := [...]int{10, 20, 30, 40, 50}
　　
array := [5]int{1: 10, 2: 20}                  //指定索引为1元素为10,索引为2元素为20
　　

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

　　
var array_ [5]int
　　
array_ = array
　　
// 数组变量的类型包括数组长度和每个元素的类型。只有这两部分都相同的数组，才是类型相 同的数组，才能互相赋值
　　

　　
// 声明一个二维整型数组，两个维度分别存储 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}}
　　

　　
// 声明一个需要 8 MB 的数组
　　
var array [1e6]int
　　
// 将数组传递给函数
　　
foo foo(array)
　　
//函数 foo 接受一个 100 万个整型值的数组
　　
func foo(array [1e6]int)
　　
{ ... }
　　
每次函数 foo 被调用时，必须在栈上分配 8 MB 的内存。之后，整个数组的值（8 MB 的内 存）被复制到刚分配的内存里。虽然 Go 语言自己会处理这个复制操作，不过还有一种更好且更 有效的方法来处理这个操作。可以只传入指向数组的指针，这样只需要复制 8 字节的数据而不是 8 MB 的内存数据到栈上，优化如下
　　
// 分配一个需要 8 MB 的数组
　　
var array [1e6]int
　　
// 将数组的地址传递给函数
　　
foo foo(&array)
　　
// 函数 foo 接受一个指向 100 万个整型值的数组的指针
　　
func foo(array *[1e6]int)
　　
{ ... }
　　
这个操作会更有效地利用内存，性能也更好。不过要意识到，因为现在传递的是指针， 所以如果改变指针指向的值，会改变共享的内存。使用切片能更好地处理这类共 享问题。