详解Go语言Slice作为函数参数的使用
codesky · 101浏览 · 发布于2021-07-02 +关注

Slice切片在Go语言中实质是一种结构体类型,本文详细的介绍了Go语言Slice作为函数参数的使用,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

目录

  • 前言

  • 问题与解析

    • 典型问题

  • 其它疑问1

    • 其它疑问2

      • 结论

        • 参考链接

          前言

          首先要明确Go语言中实质只有值传递,引用传递和指针传递是相对于参数类型来说。

          个人认为上诉的结论不对,把引用类型看做对指针的封装,一般封装为结构体,结构体是值类型,所以感觉都是值传递。不然我感觉其它语言实质不也都是值传递?不过我刚学Go,可能还没完全弄懂,这个有问题可以互相讨论下。

          Go语言中的值类型:int、float、bool、array、sturct等,声明一个值类型变量时,编译器会在栈中分配一个空间,空间里存储的就是该变量的值。

          Go语言中的引用类型:slice,map,channel,interface,func,string等,声明一个引用类型的变量,编译器会把实例的内存分配在堆上。

          string和其他语言一样,是引用类型,string的底层实现struct String { byte* str; intgo len; }; 但是因为string不允许修改,每次操作string只能生成新的对象,所以在看起来使用时像值类型。

          其实引用类型可以看作对指针的封装。

          Slice切片在Go语言中实质是一种结构体类型,源码中定义如下:

          源码位置:src/runtime/slice.go

          1

          2

          3

          4

          5

          type slice struct {

           array unsafe.Pointer

           len   int

           cap   int

          }

          从定义中我们可以知道slice是一种值类型,array是底层数组指针,它指向底层分配的数组;len是底层数组的元素个数;cap是底层数组的容量,超过容量会扩容。

          问题与解析

          典型问题

          有了上面知识的铺垫,下面我们来看下把slice作为函数参数传递的典型问题:

          1

          2

          3

          4

          5

          6

          7

          8

          9

          10

          11

          12

          13

          14

          15

          16

          17

          18

          19

          20

          21

          22

          23

          package main


          import "fmt"


          func main() {

           tmp := make([]int, 0)

              fmt.Printf("%p\n", &tmp)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

           change(tmp)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

          }


          func change(tmp []int) {

              fmt.Printf("%p\n", &tmp)

           tmp = append(tmp, 6)

              fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

          }

          //运行结果

          //0xc000004078

          //[] 0 0 0x59cde0

          //0xc0000040c0

          //[6] 1 1 0xc000014098

          //[] 0 0 0x59cde0

          这是一个典型问题,你所有疑问的基本这种类型的问题。

          疑问点:slice不是引用类型吗?把它做参数传递时实参应该同步修改啊,为什么main函数中的tmp没变?

          解析:

          从之前讲的知识中我们已经知道slice实质是一个结构体,其作为参数传递时形参实质复制了实参整个结构体的内容,其实就是值传递。

          形参分配有一份内存空间,存放和实参相同的内容,从运行结果可以看出形参的内存地址和实参是不同的。

          因为形参中底层数组指针和实参相同,所以当做修改操作时会同步修改到实参中,但是当使用append函数添加元素时,append函数返回的slice会覆盖修改到形参的内存空间中,和实参无关,所以在main函数中实参不变。可以在上面代码中看到函数中形参已变但实参未变。

          有同学看到上面解析之后可能还会有一些疑问,比如:

          append函数有扩容机制,当函数内使用append未扩容时,是不是就可以同步增加元素到实参中?
          为什么传指针就可以和实参完全同步,指针不也和引用类似吗?
          函数中使用append时,如果扩容,其中形参内存空间中底层数组的地址会被覆盖修改为新的扩容后的底层数组地址,而实参无变化。上面的代码就是如此。

          其它疑问1

          1

          2

          3

          4

          5

          6

          7

          8

          9

          10

          11

          12

          13

          14

          15

          16

          17

          18

          19

          package main


          import "fmt"


          func main() {

           tmp := make([]int, 0, 5)

           tmp = append(tmp, 1, 2, 3)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

           change(tmp)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

          }


          func change(tmp []int) {

           tmp = append(tmp, 4)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

          }

          //[1 2 3] 3 5 0xc00000c300

          //[1 2 3 4] 4 5 0xc00000c300

          //[1 2 3] 3 5 0xc00000c300

          疑问点:从代码中可以看出函数中使用append时是没有扩容的,因为形参中底层数组地址和实参是一致的,那为什么实参中没有增加元素?

          解析:

          其实实参中tmp[3]已经变为4,但是实参和形参内存空间中len和cap是独立的,形参中len修改为了4但实参中len仍然为3,所以实参中未增加元素。

          关于tmp[3]已经变为4可以从如下代码中反映出来:

          1

          2

          3

          4

          5

          6

          7

          8

          9

          10

          11

          12

          13

          14

          15

          16

          17

          18

          19

          package main


          import "fmt"


          func main() {

           tmp := make([]int, 0, 5)

           tmp = append(tmp, 1, 2, 3, 4, 5)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

           change(tmp[:3])

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

          }


          func change(tmp []int) {

           tmp = append(tmp, 6)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

          }

          //[1 2 3 4 5] 5 5 0xc00000c300

          //[1 2 3 6] 4 5 0xc00000c300

          //[1 2 3 6 5] 5 5 0xc00000c300

          可以看出实参中4已经变为6

          或者从如下代码中更为直接的看出:

          1

          2

          3

          4

          5

          6

          7

          8

          9

          10

          11

          12

          13

          14

          15

          16

          17

          18

          19

          20

          21

          22

          23

          24

          25

          26

          27

          package main


          import (

           "fmt"

           "unsafe"

          )


          func main() {

           tmp := make([]int, 0, 5)

           tmp = append(tmp, 1, 2, 3)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

           change(tmp)

           p := unsafe.Pointer(&tmp[2])

           q := uintptr(p) + 8

           t := (*int)(unsafe.Pointer(q))

           fmt.Println(*t)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

          }


          func change(tmp []int) {

           tmp = append(tmp, 4)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

          }

          //[1 2 3] 3 5 0xc00000c300

          //[1 2 3 4] 4 5 0xc00000c300

          //4

          //[1 2 3] 3 5 0xc00000c300

          用实参tmp[2]的地址往后移一个元素地址长度,得到tmp[3]的地址输出,可以看到变为了3。

          其它疑问2

          1

          2

          3

          4

          5

          6

          7

          8

          9

          10

          11

          12

          13

          14

          15

          16

          17

          18

          19

          20

          21

          22

          23

          package main


          import "fmt"


          func main() {

           tmp := make([]int, 0, 5)

           tmp = append(tmp, 1, 2, 3)

           fmt.Printf("%p\n", &tmp)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

           change(&tmp)

           fmt.Printf("%v %d %d %p\n", tmp, len(tmp), cap(tmp), tmp)

          }


          func change(tmp *[]int) {

           *tmp = append(*tmp, 4)

           fmt.Printf("%p\n", tmp)

           fmt.Printf("%v %d %d %p\n", *tmp, len(*tmp), cap(*tmp), *tmp)

          }

          //0xc000004078

          //[] 0 0 0xffdde0

          //0xc000004078

          //[1] 1 1 0xc000014098

          //[1] 1 1 0xc000014098

          疑问点:为什么指针可以同步修改到实参,*tmp = append(*tmp, 4)这不也是覆盖修改到形参吗?

          解析:

          首先明确传指针时传的是slice的地址,形参是地址而非一份和实参相同内容的内存空间,这点从代码中打印的0xc000004078地址可以看出。所以*tmp = append(*tmp, 4)这段代码覆盖修改的是0xc000004078这个地址指向的slice,即主函数中的tmp切片,这点从代码中主函数中切片tmp的底层数组地址从0xffdde0变为0xc000014098可以看出。

          结论

          当传指针时,对函数中slice的任何修改其实都是对主函数中slice的修改;当传引用,即slice本身时,对函数中slice使用append时的修改实际是对形参新分配内存空间的修改而实参不变,但当直接修改slice中值时能同步修改到实参中。


          相关推荐

          PHP实现部分字符隐藏

          沙雕mars · 910浏览 · 2019-04-28 09:47:56
          Java中ArrayList和LinkedList区别

          kenrry1992 · 379浏览 · 2019-05-08 21:14:54
          Tomcat 下载及安装配置

          manongba · 488浏览 · 2019-05-13 21:03:56
          JAVA变量介绍

          manongba · 536浏览 · 2019-05-13 21:05:52
          什么是SpringBoot

          iamitnan · 504浏览 · 2019-05-14 22:20:36
          加载中

          0评论

          评论
          分类专栏
          小鸟云服务器
          扫码进入手机网页