Go语言的指针语法和C语言类似，指针变量是指向了一个值的内存地址，类似于变量和常量，使用指针，可以在无须知道变量名字的情况下，间接读取或更新变量的值。在使用前需要申明指针

  1. var ip *int   /* 指向整型的指针 */
  2. var fp *float32 /* 指向浮点型 */

在指针变量前用*号，来获取指针指向的内容

  1. package main
  3. import "fmt"
  5. func main() {
  6.    var a int= 20   /* 声明实际变量 */
  7.    var ip *int        /* 声明指针变量 */
  9.    ip = &a  /* 指针变量的存储地址 */
  11.    fmt.Printf("a 变量的地址是: %x\n", &a  )
  13.    /* 指针变量的存储地址 */
  14.    fmt.Printf("ip 变量储存的指针地址: %x\n", ip )
  16.    /* 使用指针访问值 */
  17.    fmt.Printf("*ip 变量的值: %d\n", *ip )
  18. }

定义指针数组

  1. package main
  3. import "fmt"
  5. const MAX int = 3
  7. func main() {
  8.    a := []int{10,100,200}
  9.    var i int
  10.    var ptr [MAX]*int;
  12.    for  i = 0; i < MAX; i++ {
  13.       ptr[i] = &a[i] /* 整数地址赋值给指针数组 */
  14.    }
  16.    for  i = 0; i < MAX; i++ {
  17.       fmt.Printf("a[%d] = %d\n", i,*ptr[i] )
  18.    }
  19. }

指向指针的指针

  1. package main
  3. import "fmt"
  5. func main() {
  7.    var a int
  8.    var ptr *int
  9.    var pptr **int
  11.    a = 3000
  13.    /* 指针 ptr 地址 */
  14.    ptr = &a
  16.    /* 指向指针 ptr 地址 */
  17.    pptr = &ptr
  19.    /* 获取 pptr 的值 */
  20.    fmt.Printf("变量 a = %d\n", a )
  21.    fmt.Printf("指针变量 *ptr = %d\n", *ptr )
  22.    fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
  23. }
  25. 变量 a = 3000
  26. 指针变量 *ptr = 3000
  27. 指向指针的指针变量 **pptr = 3000

向函数传递指针参数

Go语言允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可, 通过引用或地址传参，在函数调用时可以改变其值

  1. package main
  3. import "fmt"
  5. func main() {
  6.    /* 定义局部变量 */
  7.    var a int = 100
  8.    var b int= 200
  10.    fmt.Printf("交换前 a 的值 : %d\n", a )
  11.    fmt.Printf("交换前 b 的值 : %d\n", b )
  13.    /* 调用函数用于交换值
  14.    * &a 指向 a 变量的地址
  15.    * &b 指向 b 变量的地址
  16.    */
  17.    swap(&a, &b);
  19.    fmt.Printf("交换后 a 的值 : %d\n", a )
  20.    fmt.Printf("交换后 b 的值 : %d\n", b )
  21. }
  23. func swap(x *int, y *int) {
  24.    var temp int
  25.    temp = *x    /* 保存 x 地址的值 */
  26.    *x = *y      /* 将 y 赋值给 x */
  27.    *y = temp    /* 将 temp 赋值给 y */
  28. }
  30. 交换前 a 的值 : 100
  31. 交换前 b 的值 : 200
  32. 交换后 a 的值 : 200
  33. 交换后 b 的值 : 100

指向函数的局部变量的指针

  1. func TestPtr(t *testing.T)  {
  2.     ptr1 := f()
  3.     ptr2 := f()
  5.     println(ptr1)
  6.     println(ptr2)
  8.     println(*ptr1)
  9.     println(*ptr2)
  10. }
  13. func f() *int {
  14.     v := 1
  15.     return &v
  16. }
  18. 0xc000040750
  19. 0xc000040748
  20. 1
  21. 1

上述代码很有意思，理论上在函数中分配的局部变量应该是在栈上，而通过指针返回出去之后，相当于生命周期没有在函数结束的时候被回收，实际上go的方法可以直接返回局部变量的指针，这主要依赖go是有runtime的语言，编译器在发现有变量可以逃逸出去的时候会在堆上分配变量而不是栈上，这样就可以返回该变量的指针了，且会使该地址的引用+1，当生命空间结束时，gc会去回收。
作为对比，C语言就完全需要程序员自己去控制内存了，如果需要从函数内部返回指针，那么需要程序员自己malloc在堆上分配空间，并且需要在外部使用者用完之后即使的free掉。如果直接像go那样返回指针，要么编译不过，要么也是返回一个已经不该使用的栈内存地址，使用该地址会造成严重的错误。