go语言指针

一、go语言指针

1、指针变量

指针一般是指指针变量,是指指向一个内存地址的变量

2、指针使用流程:
  • 定义指针变量。
  • 为指针变量赋值。
  • 访问指针变量中指向地址的值。
3、指针的定义

var varName *varType

  • varName表示指针变量名称
  • varType为指针提向的内容的类型
    如:var *p int 即表示一个指向整型的指针变量p

二、指针运算符

go指针运算符,和C语言类似,但只有两个运算符(没有自增这种运算)

1、取地址运算符&
  1. var num int = 200
  2. var p *int
  3. p = &num
2、获取指针变量所指向内容的运算符*
  1. var num int = 200
  2. var p *int = &num
  3. fmt.Println(*p)
3、空指针

当一个指针被定义后没有分配到任何变量时,它的值为 nil,也称这个指针为空指针(nil指针)

  1. package main
  2. import "fmt"
  3. func main() {
  4. var ptr *int
  5. fmt.Printf("ptr 的值为 : %x ", ptr) //输出:0
  6. if ptr == nil {
  7. fmt.Println("ptr是一个空指针")
  8. }
  9. }

三、指针数组

所谓指针数组就是数组中每个元素都是指针的数组。(与C语言不同的是,在go语言中,go数组不是一个指针)

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

扩展:数组指针:指向数组的指针

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main () {
  6. var num = []int {5, 8, 9}
  7. //定义数组指针
  8. var ptr *[]int
  9. //指针指向num数组
  10. ptr = &num
  11. fmt.Println(ptr) //输出:&[5 8 9]
  12. fmt.Println(*ptr) //输出:[5 8 9]
  13. for _, v := range *ptr {
  14. fmt.Println(v)
  15. }
  16. //输出: 5 8 9
  17. }

四、函数中的指针

1、指针作为函数的参数

还是来最经典的交换两个数字值的例子

  1. package main
  2. import "fmt"
  3. func Swap(x *int, y *int) {
  4. tmp := *x
  5. *x = *y
  6. *y = tmp
  7. }
  8. func main () {
  9. var a int = 100
  10. var b int = 59
  11. fmt.Printf("交换前:a = %d, b = %d ", a , b) //输出:交换前:a = 100, b = 59
  12. Swap(&a, &b)
  13. fmt.Printf("交换后:a = %d, b = %d ", a , b) //输出:交换后:a = 59, b = 100
  14. }