[译] part 15: golang 指针 pointers

https://juejin.im/post/5ca992d7e51d452b653f8f0e

什么是指针

指针是存储另一个变量的内存地址的变量。






在上面的图示中,变量b值为 156 并存储在内存地址 0x1040a124 处。变量a保存了b的地址,那么a就是指针并指向b

声明指针

* T是指针变量的类型,它指向类型为T的值。

看段代码吧,

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. b := 255
  7. var a *int = &b
  8. fmt.Printf("Type of a is %T\n", a)
  9. fmt.Println("address of b is", a)
  10. }

Run in playgroud

运算符用于获取变量的地址。上面程序的第 9 行,我们将b的地址分配给其类型为* inta。现在可以说a指向b。当我们打印a``的值时就是b`的地址。输出,

  1. Type of a is *int
  2. address of b is 0x1040a124

你可能会获得不同的地址,因为b可以在内存中的任何位置。

指针的零值

指针的零值是nil

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. a := 25
  7. var b *int
  8. if b == nil {
  9. fmt.Println("b is", b)
  10. b = &a
  11. fmt.Println("b after initialization is", b)
  12. }
  13. }

Run in playgroud

b在上述程序中最初为nil,然后将a的地址赋值给b。输出,

  1. b is <nil>
  2. b after initialisation is 0x1040a124

指针解引用

解引用指针意味着访问指针指向的变量的值。* a是解引用的语法。

看看是如何执行的,

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. b := 255
  7. a := &b
  8. fmt.Println("address of b is", a)
  9. fmt.Println("value of b is", *a)
  10. }

Run in playground

在上述程序的第 10 行,我们解引用指针a并打印它的值。正如预期的那样,它打印出b的值。该程序的输出是

  1. address of b is 0x1040a124
  2. value of b is 255

再写一个程序,我们用指针改变 b 中的值。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. b := 255
  7. a := &b
  8. fmt.Println("address of b is", a)
  9. fmt.Println("value of b is", *a)
  10. *a++
  11. fmt.Println("new value of b is", b)
  12. }

Run in playgroud

上面程序的第 12 行,我们将a指向的值增加 1,它将改变b的值,因为a指向b。因此,b的值变为 256。程序的输出是

  1. address of b is 0x1040a124
  2. value of b is 255
  3. new value of b is 256

将指针传递给函数

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func change(val *int) {
  6. *val = 55
  7. }
  8. func main() {
  9. a := 58
  10. fmt.Println("value of a before function call is",a)
  11. b := &a
  12. change(b)
  13. fmt.Println("value of a after function call is", a)
  14. }

Run in playgroud

在上面程序的第 14 行,我们传递指针变量bchange函数。在change函数内部,使用解引用来修改a的值。此程序输出,

  1. value of a before function call is 58
  2. value of a after function call is 55

不要将指向数组的指针作为函数的参数,应该改用切片

我们假设想在函数内部对数组进行一些修改,并且数组所做的修改应该对调用者可见。一种方法是将指向数组的指针作为函数的参数传递。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func modify(arr *[3]int) {
  6. (*arr)[0] = 90
  7. }
  8. func main() {
  9. a := [3]int{89, 90, 91}
  10. modify(&a)
  11. fmt.Println(a)
  12. }

Run in playgroud

在上面的程序的第 13 行,我们将数组a的地址传递给modify函数。在modify函数中,我们解除引用arr并将 90 分配给数组的第一个元素。该程序输出[90 90 91]

a [x](* a)[x]的简写。所以上面程序中的(* arr)[0]可以用arr [0]代替。让我们用这个语法重写上面的程序。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func modify(arr *[3]int) {
  6. arr[0] = 90
  7. }
  8. func main() {
  9. a := [3]int{89, 90, 91}
  10. modify(&a)
  11. fmt.Println(a)
  12. }

Run in playgroud 该程序也会输出[90 90 91]

虽然这种将指向数组的指针作为函数的参数传递并对其进行修改的方式有效,但这并不是 Go 中的惯用方法。我们有切片slice )。

我们使用切片重新上述代码,

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func modify(sls []int) {
  6. sls[0] = 90
  7. }
  8. func main() {
  9. a := [3]int{89, 90, 91}
  10. modify(a[:])
  11. fmt.Println(a)
  12. }

Run in playgroud

在上面程序的第 13 行中,我们将一个切片传递给modify函数。切片的第一个元素在modify函数内被修改为 90。该程序也输出[90 90 91]。所以忘记将指针传递给数组吧,使用切片更干净,是惯用的 Go :)。 译者注:But even this style isn't idiomatic Go. Use slices instead. 这句话是 Go 官方文档推荐的,其实重要的一点是,在 Go 中数组是定长的,所以看到按引用传递的定义func modify(arr *[3]int)是这个样子。如果我的数组要扩容还得修改入参,非常不灵活。当然还有其他的弊病,如果没有确定数组能干什么,那就按官方文档的建议来吧。

Go 不支持指针算数运算

Go 不支持指针算运算,这点和像 C 这样的其他语言不同。

  1. package main
  2. func main() {
  3. b := [...]int{109, 110, 111}
  4. p := &b
  5. p++
  6. }

Run in playgroud )

上面的程序将抛出编译错误main.go:6: invalid operation: p++ (non-numeric type *[3]int)

我在 github 中创建了一个程序,它涵盖了我们这一节讨论过的所有内容。

ft_authoradmin  ft_create_time2019-08-03 16:35
 ft_update_time2019-08-03 16:36