Go语言指针

1、Go语言指针

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

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

package main

import "fmt"

func main() {
	var a int = 10
	// 变量的地址: 20818a220
	fmt.Printf("变量的地址: %xn", &a)
}

1.1 什么是指针

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

// 指针声明格式如下：
var var_name *var-type
// 这是一个指向 int 和 float32 的指针
var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

var-type为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。

1.2 如何使用指针

指针使用流程：

1、定义指针变量。

2、为指针变量赋值。

3、访问指针变量中指向地址的值。

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

package main

import "fmt"

func main() {
	var a int = 20 /* 声明实际变量 */
	var ip *int    /* 声明指针变量 */
	ip = &a        /* 指针变量的存储地址 */
	// a 变量的地址是: 20818a220
	fmt.Printf("a 变量的地址是: %xn", &a)
	/* 指针变量的存储地址 */
	// ip 变量储存的指针地址: 20818a220
	fmt.Printf("ip 变量储存的指针地址: %xn", ip)
	/* 使用指针访问值 */
	// *ip 变量的值: 20
	fmt.Printf("*ip 变量的值: %dn", *ip)
}

1.3 空指针

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

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

package main

import "fmt"

func main() {
	var ptr *int
	// ptr 的值为 : 0
	fmt.Printf("ptr 的值为 : %xn", ptr)
	// true
	fmt.Printf("%t", ptr == nil)
	// false
	fmt.Printf("%t", ptr != nil)
}

空指针判断：

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

1.4 Go 指针数组

可以定义一个指针数组来存储地址。

// 以下声明了整型指针数组
// ptr为整型指针数组
// 因此每个元素都指向了一个地址
var ptr [MAX]*int;

实例1：

// 以下实例的三个整数将存储在指针数组中
// 指针数组的每个元素存储的是原数组每个元素的地址
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] /* 整数地址赋值给指针数组 */
	}
	/*
	 * a[0] = 10
	 * a[1] = 100
	 * a[2] = 200
	 */
	for i = 0; i < MAX; i++ {
		fmt.Printf("a[%d] = %dn", i, *ptr[i])
	}
}

实例2：

package main

import "fmt"

const max = 3

func main() {
	number := [max]int{5, 6, 7}
	// number的值是[5 6 7]
	fmt.Printf("number的值是%dn", number)
	// number值的类型是[3]int
	fmt.Printf("number值的类型是%Tn", number)
	// &number的值是&[5 6 7]
	fmt.Printf("&number的值是%dn", &number)
	// &number值的类型是*[3]int
	fmt.Printf("&number值的类型是%Tn", &number)
}

创建指针数组的时候，用 range 循环错误的使用：

package main

import "fmt"

const max = 3

func main() {
	number := [max]int{5, 6, 7}
	var ptrs [max]*int
	/*
		x的值是5
		x值的类型是int
		x的地址是824633811096
		x的值是6
		x值的类型是int
		x的地址是824633811096
		x的值是7
		x值的类型是int
		x的地址是824633811096
	*/
	// 将number数组的值的地址赋给ptrs
	// 跟for循环不一样的地方在于range循环中的x变量是临时变量
	// range循环只是将值拷贝到x变量中,因此内存地址都是一样的
	// for i, x := range number 和
	// for i, x := range &number作用一样
	for i, x := range &number {
		fmt.Printf("x的值是%dn", x)
		fmt.Printf("x值的类型是%Tn", x)
		fmt.Printf("x的地址是%dn", &x)
		ptrs[i] = &x
	}

	/*
		指针数组：索引:0 值:7 值的内存地址:824633811096
		指针数组：索引:1 值:7 值的内存地址:824633811096
		指针数组：索引:2 值:7 值的内存地址:824633811096
	*/
	for i, x := range ptrs {
		fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%dn", i, *x, x)
	}
}

创建指针数组的时候，用 range 循环正确的使用(一)：

package main

import "fmt"

const max = 3

func main() {
	number := [max]int{5, 6, 7}
	var ptrs [max]*int
	/*
		    x的值是5
			x值的类型是int
			x的地址是824633811096
			x的值是6
			x值的类型是int
			x的地址是824633811096
			x的值是7
			x值的类型是int
			x的地址是824633811096
	*/
	// 跟for循环不一样的地方在于range循环中的x变量是临时变量
	// range循环只是将值拷贝到x变量中,因此内存地址都是一样的
	// for i, x := range number 和
	// for i, x := range &number作用一样
	for i, x := range &number {
		fmt.Printf("x的值是%dn", x)
		fmt.Printf("x值的类型是%Tn", x)
		fmt.Printf("x的地址是%dn", &x)
		ptrs[i] = &number[i]
	}
	/*
		指针数组：索引:0 值:5 值的内存地址:824633770248
		指针数组：索引:1 值:6 值的内存地址:824633770256
		指针数组：索引:2 值:7 值的内存地址:824633770264
	*/
	for i, x := range ptrs {
		fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%dn", i, *x, x)
	}
}

x临时变量仅被声明一次，此后都是将迭代 number 出的值赋值给 x ， x 变量的内存地址始终未变，这样再将 x 的

地址发送给 ptrs 数组，自然也是相同的，正确使用应增加一个临时变量。

创建指针数组的时候，用 range 循环正确的使用(二)：

package main

import "fmt"

const max = 3

func main() {
	number := [max]int{5, 6, 7}
	var ptrs [max]*int
	/*
		temp的值是5
		temp值的类型是int
		temp的地址是824634417240
		temp的值是6
		temp值的类型是int
		temp的地址是824634417296
		temp的值是7
		temp值的类型是int
		temp的地址是824634417304
	*/
	// 跟for循环不一样的地方在于range循环中的x变量是临时变量
	// range循环只是将值拷贝到x变量中,因此内存地址都是一样的
	// for i, x := range number 和
	// for i, x := range &number作用一样
	for i, x := range &number {
		temp := x
		fmt.Printf("temp的值是%dn", temp)
		fmt.Printf("temp值的类型是%Tn", temp)
		fmt.Printf("temp的地址是%dn", &temp)
		ptrs[i] = &temp
	}

	/*
		指针数组：索引:0 值:5 值的内存地址:824634417240
		指针数组：索引:1 值:6 值的内存地址:824634417296
		指针数组：索引:2 值:7 值的内存地址:824634417304
	*/
	for i, x := range ptrs {
		fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%dn", i, *x, x)
	}

	/*
		0xc0000ae078 0xc0000aa058
		0xc0000ae080 0xc0000aa090
		0xc0000ae088 0xc0000aa098
	*/
	// 输出地址比对
	for i := 0; i < 3; i += 1 {
		fmt.Println(&number[i], ptrs[i])
	}
}

1.5 数组指针

// 数组指针
package main

import "fmt"

const max = 3

func main() {
	number := [max]int{5, 6, 7}
	// 指针数组
	var ptrs [max]*int
	// 数组指针
	var p *[3]int = &number

	for i, _ := range number {
		ptrs[i] = &number[i]
	}

	/*
		0xc00000c108 0xc00000c108 0xc00000c108 0xc00000c108
		0xc00000c110 0xc00000c110 0xc00000c110 0xc00000c108
		0xc00000c118 0xc00000c118 0xc00000c118 0xc00000c108
	*/
	// 输出地址对比
	for i := 0; i < 3; i += 1 {
		fmt.Println(&number[i], ptrs[i], &p[i], &(*p)[i])
	}

	/*
		5 5 5 5
		6 6 6 6
		7 7 7 7
	*/
	// 值输出
	for i := 0; i < 3; i += 1 {
		fmt.Println(number[i], *ptrs[i], p[i], (*p)[i])
	}
}

1.6 Go 指向指针的指针

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

指向指针的指针的指针：

package main

import "fmt"

func main() {
	var a int = 1
	var ptr1 *int = &a
	var ptr2 **int = &ptr1
	// 也可以写作 var ptr3 ***int = &ptr2
	var ptr3 **(*int) = &ptr2
	// 依次类推
	// a: 1
	fmt.Println("a:", a)
	// ptr1 0xc0000140b0
	fmt.Println("ptr1", ptr1)
	// ptr2 0xc000006028
	fmt.Println("ptr2", ptr2)
	// ptr3 0xc000006030
	fmt.Println("ptr3", ptr3)
	// *ptr1 1
	fmt.Println("*ptr1", *ptr1)
	// **ptr2 1
	fmt.Println("**ptr2", **ptr2)
	// 也可以写作 ***ptr3
	// **(*ptr3) 1
	fmt.Println("**(*ptr3)", **(*ptr3))
}

三重指针及其对应关系：

ptr3 - > ptr2 - > ptr1 - >变量a

package main

import "fmt"

func main() {
	var a int = 5
	// 指针
	var p1 *int = &a
	// 二级指针
	var p2 **int = &p1
	// 三级指针
	var p3 ***int = &p2
	// p1的值:824633811096    p1的目标值:5
	fmt.Printf("p1的值:%d    p1的目标值:%dn", p1, *p1)
	// p2的值:824633745448    p2的目标值:824633811096    p2的链尾目标值:5
	fmt.Printf("p2的值:%d    p2的目标值:%d    p2的链尾目标值:%dn", p2, *p2, **p2)
	// p3的值:824633745456    p3的目标值:824633745448    下一个目标值:824633811096    p3的链尾目标值:5
	fmt.Printf("p3的值:%d    p3的目标值:%d    下一个目标值:%d    p3的链尾目标值:%dn", p3, *p3, **p3, ***p3)
}

1.7 Go 向函数传递指针参数

通过引用或地址传参，在函数调用时可以改变其值。

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

如何向函数传递指针，并在函数调用后修改函数内的值：

package main

import "fmt"

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int = 200
	/*
	   交换前 a 的值 : 100
	   交换前 b 的值 : 200
	*/
	fmt.Printf("交换前 a 的值 : %dn", a)
	fmt.Printf("交换前 b 的值 : %dn", b)
	/* 调用函数用于交换值
	 * &a 指向 a 变量的地址
	 * &b 指向 b 变量的地址
	 */
	swap(&a, &b)
	/*
	   交换后 a 的值 : 200
	   交换后 b 的值 : 100
	*/
	fmt.Printf("交换后 a 的值 : %dn", a)
	fmt.Printf("交换后 b 的值 : %dn", b)
}

func swap(x *int, y *int) {
	var temp int
	temp = *x /* 保存 x 地址的值 */
	*x = *y   /* 将 y 赋值给 x */
	*y = temp /* 将 temp 赋值给 y */
}

以下是一个更简洁的变量交换实例：

package main

import "fmt"

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int = 200
	swap(&a, &b)
	/*
	   交换后 a 的值 : 200
	   交换后 b 的值 : 100
	*/
	fmt.Printf("交换后 a 的值 : %dn", a)
	fmt.Printf("交换后 b 的值 : %dn", 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
	a, b = b, a
	/*
	   交换后 a 的值 : 200
	   交换后 b 的值 : 100
	*/
	fmt.Printf("交换后 a 的值 : %dn", a)
	fmt.Printf("交换后 b 的值 : %dn", b)
}