Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。 接下来让我们来一步步学习 Go 语言指针。 我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。 Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址

  1. package main
  2. import "fmt"
  4. func main() {
  5.    var a int = 10   
  6.    fmt.Printf("变量的地址: %p\n", &a  )
  7. }
  9. /* 
  10. 执行以上代码输出结果为：
  11. 变量的地址: 0xc0000a8008
  12. */
内容 描述
什么是指针 指向了一个值的内存地址的
指针变量
Go 指针数组 你可以定义一个指针数组来存储地址
Go 指向指针的指针 Go 支持指向指针的指针
Go 向函数传递指针参数 通过引用或地址传参，在函数调用时可以改变其值

什么是指针

一个指针变量指向了一个值的内存地址
类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：

  1. var var_name *var-type

var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。以下是有效的指针声明：

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

如何使用指针

  • 定义指针变量。
  • 为指针变量赋值。
  • 访问指针变量中指向地址的值
  • 在指针类型前面加上 * 号（前缀）来获取指针所指向的内容 ```go package main import “fmt”

func main() { var a int= 20 // 声明实际变量 var ptr *int // 声明指针变量 ptr = &a // 指针变量的存储地址

fmt.Printf(“a 变量的地址是: %x\n”, &a ) fmt.Printf(“ptr变量的指针地址: %x\n”, ptr ) // 指针变量的存储地址 fmt.Printf(“ptr变量的值: %d\n”, ptr ) // 使用指针访问值 fmt.Printf(“&ptr的地址: %d\n”, &ptr )

var ptr2 = &ptr fmt.Printf(“ptr2变量的值: %d\n”, **ptr2 ) // 20

var ptr3 int = &ptr fmt.Printf(“ptr2变量的值: %d\n”, ptr3 ) // 20 }

/ a 变量的地址是: c000018080 ptr变量的指针地址: c000018080 ptr变量的值: 20 &ptr的地址: 824633778208 ptr2变量的值: 20 ptr2变量的值: 20 */

  4. <a name="pp0gj"></a>
  5. ### Go 空指针
  6. 当一个指针被定义后没有分配到任何变量时，它的值为 nil<br />nil 指针也称为空指针<br />nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值<br />一个指针变量通常缩写为 ptr
  7. ```go
  8. package main
  9. import "fmt"
  11. func main() {
  12.    var  ptr *int
  14.    fmt.Printf("ptr 的值为 : %x\n", ptr  )
  15.    //空指针判断:ptr如果是空指针,执行以下内容
  16.    if(ptr == nil){
  17.      fmt.Printf("ptr为空指针")
  18.    }
  19. }
  21. /* 
  22. ptr 的值为 : 0
  23. ptr为空指针
  24. */

Go 指针数组

ptr 为整型指针数组。因此每个元素都指向了一个值。以下实例的三个整数将存储在指针数组中：

  1. package main
  2. import "fmt"
  4. const MAX int = 3
  6. func main() {
  7.    a := []int{10,100,200}
  8.    var i int
  9.    var ptr [MAX]*int;
  11.    for  i = 0; i < MAX; i++ {
  12.       ptr[i] = &a[i] // 整数地址赋值给指针数组
  13.    }
  15.    for  i = 0; i < MAX; i++ {
  16.       fmt.Printf("a[%d] = %d\n", i,*ptr[i] )
  17.     }
  19.     *ptr[0]=7890  //这是指向a,会改变a[0]值
  20.     fmt.Println(ptr[0]==&a[0])
  21.     fmt.Println(a)
  22. }
  24. /* 
  25. 上代码执行输出结果为：
  26. a[0] = 10
  27. a[1] = 100
  28. a[2] = 200
  29. true
  30. [7890 100 200]
  31. */

创建指针数组的时候，使用 range循环 代替 for循环

  1. package main
  2. import "fmt"
  4. const MAX int = 3
  6. func main() {
  7.     number := [MAX]int{5, 6, 7}
  8.     var ptrs [MAX]*int //指针数组
  10.     //将number数组的值的地址赋给ptrs
  11.     for i, v := range number {
  12.         ptrs[i] = &number[i]
  13.         fmt.Println(i,v)
  14.     }
  15.     for i, x := range ptrs {
  16.         fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%d\n", i, *x, x)
  17.     }
  18. }
  22. /* 
  23. 上代码执行输出结果为：
  24. 0 5
  25. 1 6
  26. 2 7
  27. 指针数组：索引:0 值:5 值的内存地址:824634368032
  28. 指针数组：索引:1 值:6 值的内存地址:824634368040
  29. 指针数组：索引:2 值:7 值的内存地址:824634368048
  30. */

创建指针数组的时候，使用 range循环 错误导致的结果

  1. package main
  2. import "fmt"
  4. const MAX int = 3
  7. func main() {
  8.     number := [MAX]int{5, 6, 7}
  9.     var ptrs [MAX]*int //指针数组
  11.     //将number数组的值的地址赋给ptrs
  12.     for i, v := range &number {
  13.         ptrs[i] = &v
  14.         fmt.Println(i,v)
  15.     }
  16.     for i, x := range ptrs {
  17.         fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%d\n", i, *x, x)
  18.     }
  19. }
  21. /* 
  22. 上代码执行输出结果为：
  23. 0 5
  24. 1 6
  25. 2 7
  26. 指针数组：索引:0 值:7 值的内存地址:824634359816
  27. 指针数组：索引:1 值:7 值的内存地址:824634359816
  28. 指针数组：索引:2 值:7 值的内存地址:824634359816
  29. */

这个问题是range循环的实现逻辑引起的。跟for循环不一样的地方在于range循环中的x变量是临时变量。range循环只是将值拷贝到x变量中。因此内存地址都是一样的

Go 指针多重指向

如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。 当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址：

Go语言 指针 - 图1

指向指针的指针变量声明格式如下：

  1. var ptr **int;

指向的经典案例

以上指向指针的指针变量为整型。访问指向指针的指针变量值需要使用两个 * 号，如下所示：

  1. package main
  2. import "fmt"
  4. func main() {
  5.   var a int
  6.   var ptr *int
  7.   var pptr **int
  9.   a = 3000
  11.   ptr = &a     //指针 ptr 地址
  12.   pptr = &ptr  //指向指针 ptr 地址
  14.   fmt.Printf("变量a=%d 地址值=%x\n", a, &a)
  15.   fmt.Printf("指针变量*ptr=%d 地址值=%x\n", *ptr, ptr)
  16.   fmt.Printf("指向指针的指针变量**pptr=%d 地址值=%x\n", **pptr, *pptr)
  17. }
  19. /* 
  20. 变量a=3000 地址值=c0000a8008
  21. 指针变量*ptr=3000 地址值=c0000a8008
  22. 指向指针的指针变量**pptr=3000 地址值=c0000a8008
  23. */

三重指针及其对应关系

  1. pt3 - > pto - > ptr - >变量a
  1. package main
  2. import "fmt"
  4. func main(){
  5.   var a int = 1
  6.   var ptr1 *int = &a
  7.   var ptr2 **int = &ptr1
  8.   var ptr3 **(*int) = &ptr2 // 也可以写作：var ptr3 ***int = &ptr2
  9.   // 依次类推
  10.   fmt.Println("a:", a)
  11.   fmt.Println("ptr1", ptr1)
  12.   fmt.Println("ptr2", ptr2)
  13.   fmt.Println("ptr3", ptr3)
  14.   fmt.Println("*ptr1", *ptr1)
  15.   fmt.Println("**ptr2", **ptr2)
  16.   fmt.Println("**(*ptr3)", **(*ptr3)) // 也可以写作：***ptr3
  17. }
  1. package main
  3. import "fmt"
  4. func main(){
  5.     var a int = 5
  7.     //把ptr指针 指向ss所在地址
  8.     var ptr *int = &a
  10.     //开辟一个新的指针，指向ptr指针指向的地方
  11.     var pts *int = ptr 
  13.     //二级指针，指向一个地址，这个地址存储的是一级指针的地址
  14.     var pto **int = &ptr
  16.     //三级指针，指向一个地址，这个地址存储的是二级指针的地址，二级指针同上
  17.     var pt3 ***int = &pto
  20.     fmt.Println("a的地址:",&a, "\n 值", a, "\n\n",
  22.                 "ptr指针所在地址:",&ptr,
  23.                 "\n ptr指向的地址:",ptr,
  24.                 "\n ptr指针指向地址对应的值",*ptr,"\n\n", 
  26.                 "pts指针所在地址:",&pts,
  27.                 "\n pts指向的地址:", pts,
  28.                 "\n pts指针指向地址对应的值:",*pts,"\n\n", 
  30.                 "pto指针所在地址:",&pto,
  31.                 "\n pto指向的指针（ptr）的存储地址:",pto, 
  32.                 "\n pto指向的指针（ptr）所指向的地址: " ,*pto, 
  33.                 "\n pto最终指向的地址对应的值（a）",**pto,"\n\n",
  35.                 "pt3指针所在的地址:",&pt3,
  36.                 "\n pt3指向的指针（pto）的地址:",pt3,//等于&*pt3,
  37.                 "\n pt3指向的指针（pto）所指向的指针的（ptr）地址", *pt3, //等于&**pt3,
  38.                 "\n pt3指向的指针（pto）所指向的指针（ptr）所指向的地址（a）:",**pt3, //等于&***pt3,
  39.                 "\n pt3最终指向的地址对应的值（a）", ***pt3)
  40. }
  42. /* 
  43. 执行结果：
  44. a的地址: 0xc00009a008 
  45.  值 5 
  47.  ptr指针所在地址: 0xc000092010 
  48.  ptr指向的地址: 0xc00009a008 
  49.  ptr指针指向地址对应的值 5 
  51.  pts指针所在地址: 0xc000092018 
  52.  pts指向的地址: 0xc00009a008 
  53.  pts指针指向地址对应的值: 5 
  55.  pto指针所在地址: 0xc000092020 
  56.  pto指向的指针（ptr）的存储地址: 0xc000092010 
  57.  pto指向的指针（ptr）所指向的地址:  0xc00009a008 
  58.  pto最终指向的地址对应的值（a） 5 
  60.  pt3指针所在的地址: 0xc000092028 
  61.  pt3指向的指针（pto）的地址: 0xc000092020 
  62.  pt3指向的指针（pto）所指向的指针的（ptr）地址 0xc000092010 
  63.  pt3指向的指针（pto）所指向的指针（ptr）所指向的地址（a）: 0xc00009a008 
  64.  pt3最终指向的地址对应的值（a） 5 
  65.  */

Go 向函数传递指针参数

Go 语言允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可
以下实例演示了如何向函数传递指针，并在函数调用后修改函数内的值：

  1. package main
  2. import "fmt"
  4. func main() {
  5.    // 定义局部变量 
  6.    var a int = 100
  7.    var b int= 200
  10.    fmt.Printf("交换前 a=%d, b=%d\n", a,b )
  11.    swap(&a, &b)
  12.    fmt.Printf("交换后 a=%d, b=%d\n", a,b )
  14. }
  16. func swap(x *int, y *int) {
  17.    var temp int
  18.    temp = *x    // 保存 x 地址的值 
  19.    *x = *y      // 将 y 赋值给 x 
  20.    *y = temp    // 将 temp 赋值给 y 
  21. }
  23. /* 
  24. 交换前 a=100, b=200
  25. 交换后 a=200, b=100
  26. */

更多函数传递指针参数的案例请查看Go语言函数参数的引用传递