Go指针

Go 语言指针

Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。

接下来让我们来一步步学习 Go 语言指针。

我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

以下实例演示了变量在内存中地址：

package main

import (
    "fmt"
)

func main(){
    var name string
    name = "demon"
    fmt.Println("name变量的指针地址:",&name)
}

以上代码运行返回的结果：

name变量的指针地址: 0xc420076050

什么是指针

一个指针变量可以指向任何一个值的内存地址它指向那个值的内存地址。

类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：

var var_name(变量名) *var_name_type(数据类型)

var_name就是变量的名称，var_name_type是指针的数据类型，*用于指定变量是一个指针，例如以下的指针声明

var name *string            //指向字符串类型的指针
var age  *int                //指向整数型类型的指针

如何使用指针

指针使用流程：

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

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

package main

import (
    "fmt"
)


func main(){
    //定义局部变量num1 num2
    var num1 int = 50
    var num2 *int

    //获取num1变量的内存地址并赋值给num2变量
    num2 = &num1

    fmt.Println("num1变量的内存地址为:", &num1)
    fmt.Println("num2变量指针的地址为:", num2)

    //获取变量num1的值
    fmt.Println("num1变量的值为:", num1)
    //获取变量num2的值
    fmt.Println("num2变量的值为:", *num2)

}

以上代码返回的运行结果:

num1变量的内存地址为: 0xc42006e178
num2变量指针的地址为: 0xc42006e178
num1变量的值为: 50
num2变量的值为: 50

Go 空指针

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

nil 指针也称为空指针。

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

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

查看以下实例：

package main

import (
    "fmt"
)

func main(){
    //初始化局部变量 ptr s 分别都是空指针
    var ptr  *int
    var s      *string
    //初始化局部变量num1 num2，因为num1赋值了并且num2的指针指向了num1
    var num1 float32 = 50.123
    var num2 *float32
    num2 = &num1

    //分别输出变量的值
    fmt.Printf("ptr的空指针的值为:%v
", ptr)
    fmt.Printf("s的空指针的值为：%v
", s)
    fmt.Printf("num2的值为%v
", *num2)

    //做判断，如果是空指针的话值就是nil
    if ptr == nil{
        fmt.Println("ptr是空指针哦~")
    }

    if s == nil{
        fmt.Println("s是空指针哦~")
    }

    if num2 == nil{
        fmt.Println("num2的是空指针哦~")
    }else {
        fmt.Println("num2的值为：", *num2)
    }

}

以上代码返回的运行结果:

ptr的空指针的值为:<nil>
s的空指针的值为：<nil>
num2的值为50.123
ptr是空指针哦~
s是空指针哦~
num2的值为： 50.123

Go 语言指针数组

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

package main

import (
    "fmt"
)

func main(){
    //定义一个blance数组，并且拥有五个元素
    var blance = [5] int {1,2,3,4,5}
    //定义常量MAX为5
    const MAX int =  5
    //定义数组指针number
    var number [MAX] *int

    for i := 0; i< MAX; i++{
        //分别给number的数组中的每个索引赋值，值是引用blance数组中的每个元素的内存地址
        number[i] = &blance[i]
        fmt.Printf("blance[%d] = %d 
", i, blance[i])
    }

    fmt.Println("----------------------")

    for i := 0; i< MAX; i++{
        fmt.Printf("number[%d] = %d 
", i, *number[i])
    }

    fmt.Println("----------------------")

    for i := 0; i< MAX; i++{
        //如果blance数组与number数组一样，并且里面只的内存地址都一样，则打印两个数组元素的内存地址
        if blance[i] == *number[i] && &blance[i] == number[i]{
            fmt.Printf("blance[%d] %v   number[%d]  %v 
",i , &blance[i], i ,number[i])

        }
    }
}

以上代码返回的运行结果:

blance[0] = 1 
blance[1] = 2 
blance[2] = 3 
blance[3] = 4 
blance[4] = 5 
----------------------
number[0] = 1 
number[1] = 2 
number[2] = 3 
number[3] = 4 
number[4] = 5 
----------------------
blance[0] 0xc4200141e0   number[0]  0xc4200141e0 
blance[1] 0xc4200141e8   number[1]  0xc4200141e8 
blance[2] 0xc4200141f0   number[2]  0xc4200141f0 
blance[3] 0xc4200141f8   number[3]  0xc4200141f8 
blance[4] 0xc420014200   number[4]  0xc420014200 

来来来来，用Python来嘲讽一波golang的数组引用赋值~

#!/usr/bin/env python3
# _*_coding:utf-8_*_

__author__ = 'demon'

#声明列表l1
l1 = ['demon','18','beijing',"python","golang","linux"]
#浅拷贝列表l1中的每个元素
l2 = l1[:]

l1_len = len(l1)

for i in range(l1_len):
    #判断列表中每个元素的内存地址是否一致
    if id(l1[i]) == id(l2[i]):
        #打印两个列表中给的每个元素及内存地址
        print("l1[{}]   {:10}   l2[{}]  {:10} at {memory}".format(i,l1[i],i,l2[i],memory=id(l1[i])))

以上代码返回的运行结果:

l1[0]   demon        l2[0]  demon      at 4302152624
l1[1]   18           l2[1]  18         at 4330894536
l1[2]   beijing      l2[2]  beijing    at 4330894200
l1[3]   python       l2[3]  python     at 4329981408
l1[4]   golang       l2[4]  golang     at 4330894984
l1[5]   linux        l2[5]  linux      at 4329974728

Go 语言指向指针的指针

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

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

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

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
", a )
    fmt.Printf("指针变量 *ptr = %d
", *ptr )
    fmt.Printf("指向指针的指针变量 **pptr = %d
", **pptr)
}

以上代码返回的运行结果:

变量 a = 3000
指针变量 *ptr = 3000
指向指针的指针变量 **pptr = 3000

Go 语言指针作为函数参数

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

以下实例演示了如何向函数传递指针，并在函数调用后修改函数内的值：

package main

import (
    "fmt"
)

//可以接收指针作为参数的自定义函数
func person(name *string,age *int) string {
    //修改指针指向的name变量的值，影响了name的值
    *name = "大佬"
    fmt.Println("person函数内部的name的内存地址:", name)
    fmt.Printf("person函数内部的修改后name变量值:%s", *name)
    return  ""

}

func swap(x ,y int) string{
    //修改x,y的值，x,y作为局部变量传递进来，因为没有使用指针，所以不会影响函数外部的x,y变量值
    x, y = 50,100
    fmt.Println("swap函数内部的x变量值:", x)
    fmt.Println("swap函数内部的y变量值:", y)
    return ""
}

func main() {
    //初始化局部变量
    var name string = "demon"
    var    age     int = 18
    var x int = 10
    var y int = 20

    fmt.Println("person函数内部的修改后name变量值:", name)
    fmt.Println("person函数外部的name的内存地址:", &name)
    fmt.Println(person(&name, &age))
    fmt.Printf("person函数外部的修改后name变量值:%s 
",name)

    fmt.Println("--------------------------------------------")
    fmt.Println(swap(x,y ))
    fmt.Println("swap函数外部的x变量值:", x)
    fmt.Println("swap函数外部的y变量值:", y)

}

以上代码返回的运行结果:

person函数内部的修改后name变量值: demon
person函数外部的name的内存地址: 0xc42006e1a0
person函数内部的name的内存地址: 0xc42006e1a0
person函数内部的修改后name变量值:大佬
person函数外部的修改后name变量值:大佬 
--------------------------------------------
swap函数内部的x变量值: 50
swap函数内部的y变量值: 100

swap函数外部的x变量值: 10
swap函数外部的y变量值: 20