六、Go语言指针

1.使用&访问变量在内存中地址

package main
import "fmt"

func main() {
   var a int = 10   

   fmt.Printf("变量的地址: %x\n", &a  )
}
//输出 c000014048

2.指针

一个指针变量指向一个值的内存地址。

与变量和常量相同，在使用指针钱需要声明指针：

var var_name *var-type
//如：
var ip *int        /* 指向整型的一个指针变量*/

使用指针

指针使用流程：

• 定义指针变量。
• 为指针变量赋值。
• 访问指针变量中指向地址的值。

在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。

package main

import "fmt"

func main() {
   var a int= 204  /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )
   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )
   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}
//输出
a 变量的地址是: 20818a220
ip 变量储存的指针地址: 20818a220
*ip 变量的值: 204

空指针

当一个指针被定义后没有分配到任何变量时，它的值为 nil。

nil 指针也称为空指针。

nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。

一个指针变量通常缩写为 ptr。

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("ptr 的值为 : %x\n", ptr  )
}
//输出0，即int类型的默认值。

空指针判断：

if(ptr != nil)     /* ptr 不是空指针 */
if(ptr == nil)    /* ptr 是空指针 */

3.Go语言指针数组

package main

import "fmt"

const MAX int = 3

func main() {
    a := []int{10,100,200}
    var i int
    var ptr [MAX]*int; /*声明一个指针数组*/

    for  i = 0; i < MAX; i++ {
        ptr[i] = &a[i] /* 整数地址赋值给指针数组 */
    }

    for  i = 0; i < MAX; i++ {
        fmt.Printf("地址 a[%d] = %d \n", i,ptr[i] )
        fmt.Printf("值 a[%d] = %d \n", i,*ptr[i] )
    }
}

//输出
地址 a[0] = 824634277888 
值 a[0] = 10 
地址 a[1] = 824634277896 
值 a[1] = 100 
地址 a[2] = 824634277904 
值 a[2] = 200 

4.指向指针的指针

如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。

当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址。

var ptr **int

package main

import "fmt"

func main() {
    var a int
    var ptr *int
    var pptr **int

    a = 3000

    /* 指针 ptr 地址 */
    ptr = &a

    /* 指向指针 ptr 地址 */
    pptr = &ptr

    /* 获取 pptr 的值 */
    fmt.Printf("变量 a = %d\n", a )
    fmt.Printf("指针变量 *ptr = %d\n", *ptr )
    fmt.Printf("指针 ptr = %d\n", *pptr )
    fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}

//输出
变量 a = 3000
指针变量 *ptr = 3000
指针 ptr = 824633802832
指向指针的指针变量 **pptr = 3000

5.指针作为函数参数

Go 语言允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可。

一个交换函数：

package main

import "fmt"

func main() {
    /* 定义局部变量 */
    var a int = 100
    var b int= 200
    swap(&a, &b);

    fmt.Printf("交换后 a 的值 : %d\n", a )
    fmt.Printf("交换后 b 的值 : %d\n", b )
}

/* 交换函数这样写更加简洁，也是 go 语言的特性，可以用下，c++ 和 c# 是不能这么干的 */

func swap(x *int, y *int){
    *x, *y = *y, *x
}

不使用指针进行交换：

package main

import "fmt"

func main() {
    /* 定义局部变量 */
    var a int = 100
    var b int= 200
    swap(a, b);

    fmt.Printf("交换后 a 的值 : %d\n", a )
    fmt.Printf("交换后 b 的值 : %d\n", b )
}

func swap(x int, y int){
    x, y = y, x
}

此时输出以后发现 a,b并没有交换其数值，说明这个交换函数没有对a,b本身生效。