第 7 章 指针

指针也是一种类型，也可以创建变量，称之为指针变量。指针变量的类型为 *Type，该指针指向一个 Type 类型的变量。指针变量最大的特点就是存储的某个实际变量的内存地址，通过记录某个变量的地址，从而间接的操作该变量。

Pointers-in-Golang

7.1 创建指针

创建指针有三种方法。

  • 首先定义普通变量，再通过获取该普通变量的地址创建指针：

    1
    2
    3
    4
    // 定义普通变量 x
    x := "面向加薪学习"
    // 取普通变量 x 的地址创建指针 p
    ptr := &x

  • 先创建指针并分配好内存，再给指针指向的内存地址写入对应的值：

    1
    2
    3
    4
    5
    6
    // 创建指针
    ptr2 := new(string)
    // 给指针指向的内存地址写入对应的值
    *ptr2 = "从0到Go语言微服务架构师"
    fmt.Println(ptr2)
    fmt.Println(*ptr2)

  • 首先声明一个指针变量，再从其他变量获取内存地址给指针变量：

    1
    2
    3
    4
    5
    6
    7
    // 定义变量 x2
    x2 := "Go语言微服务架构师核心22讲"
    // 声明指针变量
    var p *string
    // 指针初始化
    p = &x2
    fmt.Println(p)

Tip：

上面举的创建指针的三种方法对学过 C 语言的人来说可能很简单，但没学过指针相关知识的人可能不太明白，特别是上面代码中出现的指针操作符 & 和 * 。

  • & 操作符可以从一个变量中取到其内存地址。
  • * 操作符如果在赋值操作值的左边，指该指针指向的变量；* 操作符如果在赋值操作符的右边，指从一个指针变量中取得变量值，又称指针的解引用。

通过下面的例子，你应该就会比较清楚的理解上面两个指针操作符了。

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
	x := "面向加薪学习"
	ptr := &x
	fmt.Println("x = ", x)   // x =  面向加薪学习
	fmt.Println("*ptr = ", *ptr) // *p =  面向加薪学习
	fmt.Println("&x = ", &x) // &x =  0x14000010290
	fmt.Println("ptr = ", ptr)   // p =  0x14000010290
}

7.2 指针的类型

*(指向变量值的数据类型) 就是对应的指针类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func pointerType() {
	mystr := "Go语言极简一本通"
	myint := 1
	mybool := false
	myfloat := 3.2
	fmt.Printf("type of &mystr is :%T\n", &mystr)
	fmt.Printf("type of &myint is :%T\n", &myint)
	fmt.Printf("type of &mybool is :%T\n", &mybool)
	fmt.Printf("type of &myfloat is :%T\n", &myfloat)
}

func main() {
	//...
	pointerType()
}

7.3 指针的零值

如果指针声明后没有进行初始化，其默认零值是 nil

1
2
3
4
5
6
7
8
9
10
11
func zeroPointer() {
	x := "从0到Go语言微服务架构师"
	var ptr *string
	fmt.Println("ptr is ", ptr)
	ptr = &x
	fmt.Println("ptr is ", ptr)
}
func main() {
	//...
	zeroPointer()
}

7.4 函数传递指针参数

在函数中对指针参数所做的修改，在函数返回后会保存相应的修改。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
	"fmt"
)

func changeByPointer(value *int) {
	*value = 200
}

func main() {
	x3 := 99
	p3 := &x3
	fmt.Println("执行changeByPointer函数之前p3是", *p3)
	changeByPointer(p3)
	fmt.Println("执行changeByPointer函数之后p3是", *p3)
}

运行程序输出如下，函数传入的是指针参数，即内存地址，所以在函数内的修改是在内存地址上的修改，在函数执行后还会保留结果。

7.5 指针与切片

切片与指针一样是引用类型，如果我们想通过一个函数改变一个数组的值，可以将该数组的切片当作参数传给函数，也可以将这个数组的指针当作参数传给函数。但 Go 中建议使用第一种方法，即将该数组的切片当作参数传给函数，因为这么写更加简洁易读。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

// 使用切片
func changeSlice(value []int) {
	value[0] = 200
}

// 使用数组指针
func changeArray(value *[3]int) {
	(*value)[0] = 200
}

func main() {
	x := [3]int{10, 20, 30}
	changeSlice(x[:])
	fmt.Println(x) // [200 20 30]

	y := [3]int{100, 200, 300}
	changeArray(&y)
	fmt.Println(y) // [200 200 300]
}

7.6 Go 中不支持指针运算

学过 C 语言的人肯定知道在 C 中支持指针的运算，例如：p++ ，但这在 Go 中是不支持的。

1
2
3
4
5
6
7
package main

func main() {
	x := [...]int{20, 30, 40}
	p := &x
	p++ // error
}

如何学习Go语言微服务，快速步入架构师

从0到Go语言微服务架构师-海报 从0到Go语言微服务架构师
添加微信 公众号更多内容
wechat gzh