Go 语言指针

go语言指针基础

Go 空指针

Go 语言指针数组

Go 语言指向指针的指针

Go 语言指针作为函数参数

 

 

go语言指针基础

获取变量内存地址

变量是一种使用方便的占位符，用于引用计算机内存地址（16进制）。

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

package main

import "fmt"

func main() {
var a int = 10

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

//输出结果:
变量的地址: 20818a220

　　

什么是指针：

 

 

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

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

var var_name *var-type

　　

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

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

　　

 

如何使用指针

指针使用流程：

• 定义指针变量。
• 为指针变量赋值（赋予的是内存地址）。
• 访问指针变量中指向地址的值。

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

package main

import "fmt"

//指针声明和赋值
func main() {
var (
//实际变量
a int = 33
//指针变量
ip *int
)
//将a的地址赋值给指针变量ip
ip = &a
fmt.Println("a的值是", a)
fmt.Println("a的地址是:", &a)
fmt.Println("指针变量ip的值是:", ip)
fmt.Println("指针ip 指向的值:", *ip)
}

//输出结果:
a的值是 33
a的地址是: 0xc000014098
指针变量ip的值是: 0xc000014098
指针ip 指向的值: 33

　　

 

Go 空指针

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

nil 指针也称为空指针。

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

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

package main

import "fmt"

func main() {
var  ptr *int

fmt.Printf("ptr 的值为 : %x\n", ptr  )
}

//输出结果:
ptr 的值为 : 0

　　

空指针判断：

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

package main

import "fmt"

func main() {
var ptr *int
if ptr == nil {
fmt.Println("空指针")
} else {
fmt.Println("非空")
}
}

//输出结果:
空指针

　　

 

Go 语言指针数组

示例：

package main

import "fmt"

func main() {
a := []int{10, 100, 200}
for i := 0; i < len(a); i++ {
fmt.Printf("a[%d] = %d\n", i, a[i])
}
}

//输出结果：
a[0] = 10
a[1] = 100
a[2] = 200

　　

有一种情况，我们可能需要保存数组，这样我们就需要使用到指针。

以下声明了整型指针数组：

var ptr [MAX]*int;

　　

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

package main

import "fmt"

func main() {
var ptr [3]*int // 声明一个长度为3的指针数组

a := []int{10, 100, 200} //定义一个实际数组

for i := 0; i < len(a); i++ {
//将地址赋值给指针
ptr[i] = &a[i]
fmt.Printf("第%d个元素的指针地址是:%d\n", i, &a[i])
}
//使用指针变量指向值，进行遍历
for j := 0; j < len(ptr); j++ {
fmt.Printf("a[%d] = %d\n", j, *ptr[j])
}
}

//输出结果:
第0个元素的指针地址是:824633762152
第1个元素的指针地址是:824633762160
第2个元素的指针地址是:824633762168
a[0] = 10
a[1] = 100
a[2] = 200

　　

 

Go 语言指向指针的指针

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

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

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

var ptr **int;

　　

以上指向指针的指针变量为整型。

访问指向指针的指针变量值需要使用两个 * 号，如下所示：

package main

import "fmt"

//指向指针的指针
func main() {
var (
a    int   //变量
ptr  *int  //指针
pptr **int //指向指针的指针
)
// 变量赋值
a = 1000
//ptr赋值 a 的地址
ptr = &a

//pptr 赋值ptr的地址
pptr = &ptr

fmt.Println("a的值", a)
fmt.Println("a的地址是", &a)

//ptr=&a 指针变量ptr 存放的是变量a的内存地址
fmt.Println("指针ptr的值是(ptr):", ptr)

// *ptr= *&a  获取在变量a内存地址存储的值，即变量a的值
fmt.Println("指针ptr指向的值(*ptr):", *ptr)

// pptr = &ptr 获取指针变量 ptr 的内存地址,即指针变量在内存中的位置
fmt.Println("指针pptr的值是(pptr):", pptr)

// *pptr = *&ptr 获取存放在指针变量ptr内存地址的存储值(存储的是变量a的内存地址)
fmt.Println("指针pptr指向的值(*pptr):", *pptr)

//等效于*ptr,获取变量a的值
fmt.Println("指针pptr指向 指针ptr指向的值(**pptr):", **pptr)
}

//输出结果:
a的值 1000
a的地址是 0xc000014098
指针ptr的值是(ptr): 0xc000014098
指针ptr指向的值(*ptr): 1000
指针pptr的值是(pptr): 0xc000006028
指针pptr指向的值(*pptr): 0xc000014098
指针pptr指向 指针ptr指向的值(**pptr): 1000

　　

package main

import "fmt"
func main(){
var a int = 5
//把ptr指针 指向ss所在地址
var ptr *int = &a
//开辟一个新的指针，指向ptr指针指向的地方
var pts *int = ptr
//二级指针，指向一个地址，这个地址存储的是一级指针的地址
var pto **int = &ptr
//三级指针，指向一个地址，这个地址存储的是二级指针的地址，二级指针同上
var pt3 ***int = &pto
fmt.Println("a的地址:",&a,
"\n 值", a, "\n\n",

"ptr指针所在地址:",&ptr,
"\n ptr指向的地址:",ptr,
"\n ptr指针指向地址对应的值",*ptr,"\n\n",

"pts指针所在地址:",&pts,
"\n pts指向的地址:", pts,
"\n pts指针指向地址对应的值:",*pts,"\n\n",

"pto指针所在地址:",&pto,
"\n pto指向的指针（ptr）的存储地址:",pto,
"\n pto指向的指针（ptr）所指向的地址: " ,*pto,
"\n pto最终指向的地址对应的值（a）",**pto,"\n\n",

"pt3指针所在的地址:",&pt3,
"\n pt3指向的指针（pto）的地址:",pt3,//等于&*pt3,
"\n pt3指向的指针（pto）所指向的指针的（ptr）地址", *pt3, //等于&**pt3,
"\n pt3指向的指针（pto）所指向的指针（ptr）所指向的地址（a）:",**pt3, //等于&***pt3,
"\n pt3最终指向的地址对应的值（a）", ***pt3)

}

//输出结果:
a的地址: 0xc00009a008
值 5

ptr指针所在地址: 0xc000092010
ptr指向的地址: 0xc00009a008
ptr指针指向地址对应的值 5

pts指针所在地址: 0xc000092018
pts指向的地址: 0xc00009a008
pts指针指向地址对应的值: 5

pto指针所在地址: 0xc000092020
pto指向的指针（ptr）的存储地址: 0xc000092010
pto指向的指针（ptr）所指向的地址:  0xc00009a008
pto最终指向的地址对应的值（a） 5

pt3指针所在的地址: 0xc000092028
pt3指向的指针（pto）的地址: 0xc000092020
pt3指向的指针（pto）所指向的指针的（ptr）地址 0xc000092010
pt3指向的指针（pto）所指向的指针（ptr）所指向的地址（a）: 0xc00009a008
pt3最终指向的地址对应的值（a） 5

　　

 

Go 语言指针作为函数参数

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

指针属于引用类型。

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

package main

import "fmt"

func main() {
var (
a int = 10
b int = 20
)
fmt.Printf("交换前a=%d,b=%d\n", a, b)
//调用函数，将指针作为参数传递
swap(&a, &b)
fmt.Printf("交换后a=%d,b=%d\n", a, b)
}

//定义两个形参，类型是指针(&a,&b作为参数传递进入，因此，*x和&a是与同一个内存地址关联。*y与&b与同一个内存地址关联)
func swap(x, y *int) {
*x, *y = *y, *x
}

//输出结果:
交换前a=10,b=20
交换后a=20,b=10

　　

package main

import "fmt"

//实际值的传递
func main() {
var (
a int = 10
b int = 20
)
fmt.Printf("交换前a=%d,b=%d\n", a, b)
//将变量a，b作为参数传递，并使用x，y接收函数的返回值
x, y := swap(a, b)
fmt.Printf("交换后a=%d,b=%d\n", x, y)
}

func swap(x, y int) (a, b int) {
//值传递，两数交换.
x, y = y, x
fmt.Printf("swap里x=%d,y=%d\n", x, y)
//需要将交换后的结果，作为返回值传递
return x, y
}

//输出结果:
交换前a=10,b=20
swap里x=20,y=10
交换后a=20,b=10