什么是指针

  • 指针是指向另一个变量地址的变量。
  • Go 语言的指针同时也强调安全性，不会出现迷途指针（dangling pointers）

指针 - 图1

& 和 * 符号

  • 变量会将它们的值存储在计算机的 RAM 里，存储位置就是该变量的内存地址。
  • & 表示地址操作符，通过 & 可以获得变量的内存地址。
  • & 操作符无法获得字符串/数值/布尔字面值的地址。
    • &42，&“hello”这些都会导致编译器报错
  • 操作符与 & 的作用相反，它用来解引用，提供内存地址指向的值。

指针 - 图2

  • C 语言中的内存地址可以通过例如 address++ 这样的指针运算进行操作，但是在 Go 里面不允许这种不安全操作。 
  1. package main
  3. import "fmt"
  5. func main() {
  6.     answer := 42
  7.     fmt.Println(&answer)
  9.     address := &answer
  10.     fmt.Println(*address)
  11. }

指针类型

  • 指针存储的是内存地址。 
  1. package main
  3. import "fmt"
  5. func main() {
  6.     answer := 42
  7.     address := &answer
  9.     fmt.Printf("address is a %T\n", address)
  10. }
  • 指针类型和其它普通类型一样，出现在所有需要用到类型的地方，如变量声明、函数形参、返回值类型、结构体字段等。 
  1. package main
  3. import "fmt"
  5. func main() {
  6.     canada := "Canada"
  8.     var home *string
  9.     fmt.Printf("home is a %T\n", home)
  11.     home = &canada
  12.     fmt.Println(*home)
  13. }
  • 将 * 放在类型前面表示声明指针类型
  • 将 * 放在变量前面表示解引用操作

指针就是用来指向的

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var administrator *string
  8.     scolese := "Christopher J. Scolese"
  9.     administrator = &scolese
  10.     fmt.Println(*administrator)
  12.     bolden := "Charles F. Bolden"
  13.     administrator = &bolden
  14.     fmt.Println(*administrator)
  15.     bolden = "Charles Frank Bolden Jr."
  16.     fmt.Println(*administrator)
  17.     *administrator = "Maj. Gen. Charles Frank Bolden Jr."
  18.     fmt.Println(bolden)
  19.     major := administrator
  20.     *major = "Major General Charles Frank Bolden Jr."
  21.     fmt.Println(bolden)
  22.     fmt.Println(administrator == major)
  23.     lightfoot := "Robert M. Lightfoot Jr."
  24.     administrator = &lightfoot
  25.     fmt.Println(administrator == major)
  26.     charles := *major
  27.     *major = "Charles Bolden"
  28.     fmt.Println(charles)
  29.     fmt.Println(bolden)
  30.     charles = "Charles Bolden"
  31.     fmt.Println(charles == bolden)
  32.     fmt.Println(&charles == &bolden)
  33. }
  • 两个指针变量持有相同的内存地址，那么它们就是相等。

指针 - 图3

指向结构的指针

  • 与字符串和数值不一样，复合字面量的前面可以放置 &。
  • 访问字段时，对结构体进行解引用并不是必须的。 
  1. package main
  3. import "fmt"
  5. func main() {
  6.     type person struct {
  7.         name, superpower string
  8.         age              int
  9.     }
  11.     timmy := &person{
  12.         name: "Timothy",
  13.         age:  10,
  14.     }
  15.     timmy.superpower = "flying"
  17.     fmt.Printf("%+v\n", timmy)
  18. }

指向数组的指针

  • 和结构体一样，可以把 & 放在数组的复合字面值前面来创建指向数组的指针。 
  1. package main
  3. import "fmt"
  5. func main() {
  6.     superpowers := &[3]string{"flight", "invisibility", "super strength"}
  8.     fmt.Println(superpowers[0])
  9.     fmt.Println(superpowers[1:2])
  10. }
  • 数组在执行索引或切片操作时会自动解引用。没有必要写 (*superpower)[0] 这种形式。
  • 与 C 语言不一样，Go 里面数组和指针式两种完全独立的类型。
  • slice 和 map 的复合字面值前面也可以放置 & 操作符，但是 Go 并没有为它们提供自动解引用的功能。

实现修改

  • Go 语言的函数和方法都是按值传递参数的，这意味着函数总是操作于被传递参数的副本。
  • 当指针被传递到函数时，函数将接收传入的内存地址的副本。之后函数可以通过解引用内存地址来修改指针指向的值。 
  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name, superpower string
  7.     age              int
  8. }
  10. func birthday(p *person) {
  11.     p.age++
  12. }
  14. func main() {
  15.     rebecca := person{
  16.         name:       "Rebecca",
  17.         superpower: "imagination",
  18.         age:        14,
  19.     }
  21.     birthday(&rebecca)
  23.     fmt.Printf("%+v\n", rebecca)
  24. }

指针接收者

  • 方法的接收者和方法的参数在处理指针方面是很相似的。 
  1. package main
  3. import "fmt"
  5. type person struct {
  6.     name string
  7.     age  int
  8. }
  10. func (p *person) birthday() {
  11.     p.age++
  12. }
  14. func main() {
  15.     terry := &person{
  16.         name: "Terry",
  17.         age:  15,
  18.     }
  19.     terry.birthday()
  20.     fmt.Printf("%+v\n", terry)
  21.     nathan := person{
  22.         name: "Nathan",
  23.         age:  17,
  24.     }
  25.     nathan.birthday()
  26.     fmt.Printf("%+v\n", nathan)
  27. }
  • Go 语言在变量通过点标记法进行调用的时候，自动使用 & 取得变量的内存地址。
    • 所以不用写 (&nathan).birthday() 这种形式也可以正常运行。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func main() {
  9.     const layout = "Mon, Jan 2, 2006"
  11.     day := time.Now()
  12.     tomorrow := day.Add(24 * time.Hour)
  14.     fmt.Println(day.Format(layout))
  15.     fmt.Println(tomorrow.Format(layout))
  16. }
  • 使用指针作为接收者的策略应该始终如一：
  • 如果一种类型的某些方法需要用到指针作为接收者，就应该为这种类型的所有方法都是用指针作为接收者。

内部指针

  • Go 语言提供了 内部指针 这种特性。
  • 它用于确定结构体中指定字段的内存地址。
  • & 操作符不仅可以获得结构体的内存地址，还可以获得结构体中指定字段的内存地址。 
  1. package main
  3. import "fmt"
  5. type stats struct {
  6.     level             int
  7.     endurance, health int
  8. }
  10. func levelUp(s *stats) {
  11.     s.level++
  12.     s.endurance = 42 + (14 * s.level)
  13.     s.health = 5 * s.endurance
  14. }
  16. func main() {
  17.     type character struct {
  18.         name  string
  19.         stats stats
  20.     }
  22.     player := character{name: "Matthias"}
  23.     levelUp(&player.stats)
  25.     fmt.Printf("%+v\n", player.stats)
  26. }

修改数组

  • 函数通过指针对数组的元素进行修改。 
  1. package main
  3. import "fmt"
  5. func reset(board *[8][8]rune) {
  6.     board[0][0] = 'r'
  7.     // ...
  8. }
  10. func main() {
  11.     var board [8][8]rune
  12.     reset(&board)
  14.     fmt.Printf("%c", board[0][0])
  15. }

隐式的指针

  • Go 语言里一些内置的集合类型就在暗中使用指针。
  • map 在被赋值或者被作为参数传递的时候不会被复制。
    • map 就是一种隐式指针。
    • 这种写法就是多此一举：func demolish(planets *map[string]string)
  • map 的键和值都可以是指针类型
  • 需要将指针指向 map 的情况并不多见

slice 指向数组

  • 之前说过 slice 是指向数组的窗口，实际上 slice 在指向数组元素的时候也使用了指针。
  • 每个 slice 内部都会被表示为一个包含 3 个元素的结构，它们分别指向：
    • 数组的指针
    • slice 的容量
    • slice 的长度
  • 当 slice 被直接传递至函数或方法时，slice 的内部指针就可以对底层数据进行修改。
  • 指向 slice 的显式指针的唯一作用就是修改 slice 本身：slice 的长度、容量以及起始偏移量。 
  1. package main
  3. import "fmt"
  5. func reclassify(planets *[]string) {
  6.     *planets = (*planets)[0:8]
  7. }
  9. func main() {
  10.     planets := []string{
  11.         "Mercury", "Venus", "Earth", "Mars",
  12.         "Jupiter", "Saturn", "Uranus", "Neptune",
  13.         "Pluto",
  14.     }
  15.     reclassify(&planets)
  17.     fmt.Println(planets)
  18. }

指针和接口

  1. package main
  3. import (
  4.     "fmt"
  5.     "strings"
  6. )
  8. type talker interface {
  9.     talk() string
  10. }
  12. func shout(t talker) {
  13.     louder := strings.ToUpper(t.talk())
  14.     fmt.Println(louder)
  15. }
  17. type martian struct{}
  19. func (m martian) talk() string {
  20.     return "nack nack"
  21. }
  23. func main() {
  24.     shout(martian{})
  25.     shout(&martian{})
  26. }
  • 本例中，无论 martian 还是指向 martian 的指针，都可以满足 talker 接口。
  • 如果方法使用的是指针接收者，那么情况会有所不同。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "strings"
  6. )
  8. type talker interface {
  9.     talk() string
  10. }
  12. func shout(t talker) {
  13.     louder := strings.ToUpper(t.talk())
  14.     fmt.Println(louder)
  15. }
  17. type laser int
  19. func (l *laser) talk() string {
  20.     return strings.Repeat("pew ", int(*l))
  21. }
  23. func main() {
  24.     pew := laser(2)
  25.     shout(&pew)
  26. }

明智的使用指针

  • 应合理使用指针，不要过度使用指针。

作业题

  • 编写一个可以让海龟上下左右移动的程序：
    • 程序中的海龟需要存储一个位置（x，y）
    • 正数坐标表示向下或向右
    • 通过使用方法对相应的变量实施自增和自减来实现移动
    • 请使用 main 函数测试这些方法并打印出海龟的最终位置
  1. package main
  3. import "fmt"
  5. type turtle struct {
  6.     x, y int
  7. }
  9. func (t *turtle) up() {
  10.     t.y--
  11. }
  13. func (t *turtle) down() {
  14.     t.y++
  15. }
  17. func (t *turtle) left() {
  18.     t.x--
  19. }
  21. func (t *turtle) right() {
  22.     t.x++
  23. }
  25. func main() {
  26.     var t turtle
  27.     t.up()
  28.     t.up()
  29.     t.left()
  30.     t.left()
  31.     fmt.Println(t)
  32.     t.down()
  33.     t.down()
  34.     t.right()
  35.     t.right()
  36.     fmt.Println(t)
  37. }