黑马程序员技术交流社区

标题: 【上海校区】04.go数组 [打印本页]

作者: 不二晨    时间: 2018-12-18 16:59
标题: 【上海校区】04.go数组
1.数组的声明:



package main

import (
        "fmt"
)

func main() {
        //声明一个包含 5 个元素的整型数组,默认初始化
        var array [5]int
        fmt.Println(array[1])
        array[1] = 1

        //用具体值初始化每个元素
        array2 := [5]int{10, 20, 30, 40, 50}
        fmt.Println(array[1])
        array2[1] = 1

        // 容量由初始化值的数量决定
        array3 := [...]int{10, 20, 30, 40, 50}
        fmt.Println(array[1])
        array3[0] = 1
        //声明包含 5 个元素的指向整数的数组
        array4 := [5]*int{0: new(int), 1: new(int)}
        //用整型指针初始化索引为 0 和 1 的数组元素
        *array4[0] = 10

        //---------------------------
        // 声明第一个包含 5 个元素的字符串数组
        var array5 [5]string
        array5[1] = "123"
        // 声明第二个包含 5 个元素的字符串数组
        // 用颜色初始化数组
        array6 := [5]string{"Red", "Blue", "Green", "Yellow", "Pink"}
        array6[0] = "test"
        // 把 array2 的值复制到 array1
        array5 = array6
       


}


2.编译器会阻止类型不同的数组互相赋值


// 声明第一个包含 4 个元素的字符串数组
var array1 [4]string
// 声明第二个包含 5 个元素的字符串数组
// 使用颜色初始化数组
array2 := [5]string{"Red", "Blue", "Green", "Yellow", "Pink"}
// 将 array2 复制给 array1
array1 = array2


Compiler Error:
cannot use array2 (type [5]string) as type [4]string in assignment
复制数组指针,只会复制指针的值,而不会复制指针所指向的值,如代码清单 4-9所示




3.数组的传递



根据内存和性能来看,在函数间传递数组是一个开销很大的操作。在函数之间传递变量时,
总是以值的方式传递的。如果这个变量是一个数组,意味着整个数组,不管有多长,都会完整复
制,并传递给函数。
为了考察这个操作,我们来创建一个包含 100 万个 int 类型元素的数组。在 64 位架构上,
这将需要 800 万字节,即 8 MB 的内存。如果声明了这种大小的数组,并将其传递给函数,会发
生什么呢?如代码清单 4-14 所示。
代码清单 4-14 使用值传递,在函数间传递大数组

// 声明一个需要 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 的内存数据到栈上,如代码清单 4-15 所示。
代码清单 4-15 使用指针在函数间传递大数组
// 分配一个需要 8 MB 的数组
var array [1e6]int
// 将数组的地址传递给函数 foo
foo(&array)
// 函数 foo 接受一个指向 100 万个整型值的数组的指针
func foo(array *[1e6]int) {
...
}

这次函数 foo 接受一个指向 100 万个整型值的数组的指针。现在将数组的地址传入函数,
只需要在栈上分配 8 字节的内存给指针就可以。
这个操作会更有效地利用内存,性能也更好。不过要意识到,因为现在传递的是指针,
所以如果改变指针指向的值,会改变共享的内存。如你所见,使用切片能更好地处理这类共
享问题。
---------------------
【转载】仅作分享,侵删
作者:鱼酱2333
原文:https://blog.csdn.net/hiwoshixiaoyu/article/details/78950576



作者: 不二晨    时间: 2018-12-18 17:55
奈斯
作者: 梦缠绕的时候    时间: 2018-12-20 16:42





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2