Go 参数传递是传值还是传引用

什么是传值(值传递)?

     传值的意思是:函数传递的总是原来这个东西的一个副本、一个副拷贝。比如我们传递一个 int 类型的参数,传递

的其实这个参数的一个副本;传递一个指针类型的参数,其实传递的是这个指针的一份拷贝,而不是这个指针指向的

    对于 int 这类基础类型的我们可以很容易理解,它们就是一个拷贝,但是指针呢?我们可以通过它修改原来的值,怎

么会是一个拷贝呢?看如下示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main
 
import "fmt"
 
func modify(ip *int) {
    fmt.Printf("函数里接收指针的内存地址是:%p\n",&ip)
 
    *ip = 1
}
 
func main() {
    i := 10
    ip := &i
 
    fmt.Printf("原始指针的内存地址是:%p\n",&ip)
 
    modify(ip)
    fmt.Println("int 值被修改了,新值是:",i)
}

  输出结果如下:

1
2
3
原始指针的内存地址是:0xc00007e018
函数里接收指针的内存地址是:0xc00007e028
int 值被修改了,新值是: 1

  我们都知道,任何存放在内存里的东西都有自己的地址,指针也不例外,它虽然指向别的数据,但是也有存放该指

针的内存

       首先,我们声明了一个变量 i,值为 10,它的内存存放地址是 0xc000056080,通过这个地址我们可以找到变量 i,

这个内存地址也就是变量 i 的指针 ip,指针 ip 是一个指针类型的变量,它也需要内存存放它,它的内存地址是 0xc0000

7e018,在我们传递指针变量 ip 给 modify 函数的时候,是对这个指针变量的一个拷贝,所以新拷贝的指针变量 ip 它的内

存地址就变了,是新的 0xc00007e028,不管是 0xc00007e018 还是 xc00007e028 我们都可以称之为指针的指针,他们

指向同一个指针 0xc000056080,这个 0xc000056080 又指向 变量 i,这也就是为什么我们可以修改变量 i 的值

什么是引用传递? 

       在 Go 语言中没有引用传递,以上面的例子为例,如果在 modify 函数里面打印的地址不变,那么就是引用传递

迷惑 Map

       了解清楚了值传递和引用传递,但是对于 Map 类型来说,可能觉得还是迷惑,一个是我们可以通过方法修改它的内容,

二个是它没有明显的指针,如下示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
 
import "fmt"
 
func modify(p map[string]int) {
    fmt.Printf("函数里接收到的map内存地址:%p\n",&p)
 
    p["张三"] = 25
}
 
func main() {
    // 声明一个 map
    persons := make(map[string]int)
    persons["张三"] = 19
 
    mp := &persons
    fmt.Printf("原始map的内存地址是:%p\n",mp)
 
    modify(persons)
    fmt.Println("map值被修改了,新值是:",persons)
}

  运行打印输出结果:

1
2
3
原始map的内存地址是:0xc000006028
函数里接收到的map内存地址:0xc000006038
map值被修改了,新值是: map[张三:25]

  两个内存地址不一样,说明是值传递,那么为什么是值传递我们还可以修改 Map 的内容呢?我们先看一个

自己实现的 struct ,如下示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main
 
import "fmt"
 
// 声明一个结构体
type Person struct {
    Name string
}
 
func modify(p Person) {
    fmt.Printf("函数里接收到的Person内存地址:%p\n",&p)
 
    p.Name = "李四"
}
 
func main() {
    p := Person{"张三"}
    fmt.Printf("原始Person的内存地址是:%p\n",&p)
 
    modify(p)
    fmt.Println(p)
}

  运行打印输出:

1
2
3
原始Person的内存地址是:0xc00004a1c0
函数里接收到的Person内存地址:0xc00004a1d0
{张三}

  我们看到,自己定义的 Person 类型,在传递参数的时候也是值传递,但是它的值并没有被修改,这也就

是说 map 类型 和我们自己定义 struct 类型是不一样的,我们把 modify 函数接收的参数改为 Person 的指针:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main
 
import "fmt"
 
// 声明一个结构体
type Person struct {
    Name string
}
 
func modify(p *Person) {
    fmt.Printf("函数里接收到的Person内存地址:%p\n",&p)
 
    p.Name = "李四"
}
 
func main() {
    p := Person{"张三"}
    fmt.Printf("原始Person的内存地址是:%p\n",&p)
 
    modify(&p)
    fmt.Println(p)
}

  运行打印结果:

1
2
3
原始Person的内存地址是:0xc00004a1c0
函数里接收到的Person内存地址:0xc00007e020
{李四}

  看上面的输出结果,我们发现这次被修改了,那么指针类型的可以被修改,非指针类型的不能被修改,是不是我们

使用 make 创建的 map 就是一个指针类型呢?,看一下 Go 源码:

       源码地址:https://github.com/golang/go/blob/master/src/runtime/map.go

1
2
3
func makemap64(t *maptype, hint int64, h *hmap) *hmap {
    // 省略无关代码
}

  我们看到 make 函数返回的是一个 hmap 类型的指针 *hmap,也就是 map == *hmap。现在再来看 func modify(p Person) 

其实就是 func modify(p *Persoon) ,所以,这里 Go 通过 make 函数,为我们省去了指针的操作,在这里 map 可以理解为引用

类型但不是传引用

Slice 类型

       slice 类型也是引用类型,它也可以在函数中修改对应的内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
 
import "fmt"
 
func modify(ages []int) {
    fmt.Printf("函数里接收到 slice 的内存地址:%p\n",ages)
    ages[0] = 6
}
 
func main() {
    ages := []int{10,20,30}
    fmt.Printf("原始 slice 的内存地址:%p\n",ages)
 
    modify(ages)
    fmt.Println(ages)
}

  运行打印结果,发现的确是被修改了,而且在这里我们打印 slice 内存地址可以直接通过 %p,不用使用

& 取地址符转换,我们看一下 fmt.Printf 源码:

1
2
3
4
5
6
7
8
9
10
11
func (p *pp) fmtPointer(value reflect.Value, verb rune) {
    var u uintptr
    switch value.Kind() {
    case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
        u = value.Pointer()
    default:
        p.badVerb(verb)
        return
    }
        // 省略部分代码
}

  通过上面的源码发现,对于 map、slice 等被当成指针处理,通过 value.Pointer() 获取对应值的指针:

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
28
29
30
func (v Value) Pointer() uintptr {
    // TODO: deprecate
    k := v.kind()
    switch k {
    case Chan, Map, Ptr, UnsafePointer:
        return uintptr(v.pointer())
    case Func:
        if v.flag&flagMethod != 0 {
            // As the doc comment says, the returned pointer is an
            // underlying code pointer but not necessarily enough to
            // identify a single function uniquely. All method expressions
            // created via reflect have the same underlying code pointer,
            // so their Pointers are equal. The function used here must
            // match the one used in makeMethodValue.
            f := methodValueCall
            return **(**uintptr)(unsafe.Pointer(&f))
        }
        p := v.pointer()
        // Non-nil func value points at data block.
        // First word of data block is actual code.
        if p != nil {
            p = *(*unsafe.Pointer)(p)
        }
        return uintptr(p)
 
    case Slice:
        return (*SliceHeader)(v.ptr).Data
    }
    panic(&ValueError{"reflect.Value.Pointer", v.kind()})
}

  看上面的代码,如果类型是 slice 的话返回的是 slice 这个结构体里,字段 Data 第一个元素的地址:

1
2
3
4
5
6
7
8
9
10
11
type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}
 
type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

  所以,我们通过 %p 打印的 slice 变量 ages 的地址其实就是内部存储数组元素的地址,slice 是一种结构体 + 

元素指针的混合类型

      Go 语言中所有的传参都是值传递,都是一个副本、一个拷贝。因为拷贝的内容是非引用类型(int、string、struct等这些),这样就在函数

中无法修改原内容数据的;有的是引用类型(map、slice等),这样的就可以修改原内容数据

      是否可以修改原内容数据,和传值、传引用没有必然的关系,在 Go 语言中,虽然只有传值,但是我们也可以修改原内容数据,因为参数

是引用类型,引用类型和传引用是两个概念

     Go 只有值传递

posted @   流光瞬息  阅读(3289)  评论(1编辑  收藏  举报
点击右上角即可分享
微信分享提示