• 深入理解golang — 数组(array)、切片(slice)、map


     我比较喜欢先给出代码,然后得出结论

    数组

     1 package main
     2 
     3 import (
     4     "fmt"
     5 )
     6 
     7 func main() {
     8     arr := [...]int{1, 2, 3}
     9     //打印初始的指针
    10     fmt.Printf("the pointer is : %p 
    ", &arr)
    11     printPointer(arr)
    12 }
    13 
    14 func printPointer(any interface{}) {
    15     fmt.Printf("the pointer is : %p 
    ", &any)
    16 }

    结果

    1 the pointer is : 0xc082008580 
    2 the pointer is : 0xc0820001d0 

    切片

     1 package main
     2 
     3 import (
     4     "fmt"
     5 )
     6 
     7 func main() {
     8     arr := make([]int, 3)
     9     //打印初始的指针
    10     fmt.Printf("the pointer is : %p 
    ", arr)
    11     printPointer(arr)
    12 }
    13 
    14 func printPointer(any interface{}) {
    15     fmt.Printf("the pointer is : %p 
    ", any)
    16 }

    结果

    1 the pointer is : 0xc082008580 
    2 the pointer is : 0xc082008580 

    map

     1 package main
     2 
     3 import (
     4     "fmt"
     5 )
     6 
     7 func main() {
     8     arr := make(map[int]string)
     9     //arr := [3]int{1, 2, 3}
    10     //打印初始的指针
    11     fmt.Printf("the pointer is : %p 
    ", arr)
    12     printPointer(arr)
    13 }
    14 
    15 func printPointer(any interface{}) {
    16     fmt.Printf("the pointer is : %p 
    ", any)
    17 }

    运行结果

    1 the pointer is : 0xc082007c80 
    2 the pointer is : 0xc082007c80 

    由此,我们看到数组本身传过去的是值,传到函数之后,被开辟了另外一个空间。

    因为数组就是他本身。这一句好像不太好理解。

    这是切片 arr := make([]int, 3)  而arr 本身不是一个数组,至少不是我们所想要的指向的一个数组。只是arr里有一个地址指向数组。

    这么举个例子:

    arr := [...]int{1,2,3,4,5} 这是一个数组,懂得go语言的都明白。  arr本身就是数组

    arrSlice := arr[0:5]  这是一个切片。 打印所得的值是一样的,和上面。  arrSlice本身不是数组,只是arrSlice本身有一个值是指向arr的指针。

    切片是指一个结构体,大体结构像这样

    1 struct slice{
    2     ptr *Elem
    3     len int
    4     cap int
    5 }

    也就是说,上面的arrSlice其实是一个结构体。里面有一个属性 ptr指向数组 arr

    其实arrSlice也是传到函数里,也是进行了复制。但是尽管传过去是一个复制的结构体,他的属性ptr,没有变。还是一个指向原数组的指针。

    下面的例子见证他自己传过去,是一个复制的过程:

     1 package main
     2 
     3 import (
     4     "fmt"
     5 )
     6 
     7 func main() {
     8     arrSlice := make([]int, 4)
     9     fmt.Printf("the pointer is : %p 
    ", arrSlice)
    10     fmt.Printf("the pointer is : %p 
    ", &arrSlice) //这是arrSlice本身的指针,也就是结构体的指针
    11     printPointer(arrSlice)
    12 }
    13 
    14 func printPointer(any interface{}) {
    15     fmt.Printf("the pointer is : %p 
    ", any) 
    16     fmt.Printf("the pointer is : %p 
    ", &any) //打印传过来的结构体arrSlice的指针
    17 }

    看结果:

    1 the pointer is : 0xc0820085a0 
    2 the pointer is : 0xc082008580 
    3 the pointer is : 0xc0820085a0 
    4 the pointer is : 0xc0820001d0 

    第1、3个的打印是打印这个结构体的ptr属性,也就是指向数组的指针。

    其实这个结构体传到函数里,是一个复制的过程,第2、4的指针不一样。

    大家在对照下面的图片理解一下:

  • 相关阅读:
    动手动脑
    大道至简第七八章读后感
    super 的用法
    第六章
    课后作业
    大道至简第五章读后感
    课后作业
    大道至简第四章读后感
    大道至简——第六章
    Java数组课后作业
  • 原文地址:https://www.cnblogs.com/aqsmoke/p/3957859.html
Copyright © 2020-2023  润新知