3-1. go指针

Fred 收录于 go基础

2025-05-15 2025-05-15 约 2300 字预计阅读 5 分钟 - 次阅读

1 Go中的指针

要搞明白Go语言中的指针需要先知道三个概念

指针地址
指针类型
指针取值

Go语言中的指针操作非常简单，我们只需要记住两个符号：&：取地址，*：根据地址取值

1.1 关于指针

我们知道变量是用来存储数据的，变量的本质是给存储数据的内存地址起了一个好记的别名。比如我们定义了一个变量a:=10，这个时候可以直接通过a这个变量来读取内存中保存的10这个值。在计算机底层a这个变量其实对应了一个内存地址。
指针也是一个变量，但它是一种特殊的变量，它存储的数据不是一个普通的值，而是另一个变量的内存地址。

1.2 指针地址和指针类型

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。
Go 语言中使用&字符放在变量前面对变量进行取地址操作。Go语言中的值类型（int、float、bool、string、array、struct）都有对应的指针类型，如：

1

*int、，*int64、*string等

取变量指针的语法如下：

1

ptr := &v

其中：

v：代表被取地址的变量，类型为T
ptr：用于接收地址的变量，ptr的类型就为*T，被称做T的指针类型。* 代表指针

举个例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

func main() {
	var a = 10
	var b = &a
	println(&a) 	//0xc00003df60
	println(&b)		//0xc00003df68
	println(b)		//0xc00003df60
	println(*(&b))	//0xc00003df60
}

1.3 指针取值

在对普通变量进行&操作符取地址后，会获得这个变量指针，然后可以对指针使用*操作，也就是指针取值

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


// 指针取值
var c = 20
// 得到c的地址，赋值给d
var d = &c
// 打印d的值，也就是c的地址
fmt.Println(d)
// 取出d指针所对应的值
fmt.Println(*d)
// c对应地址的值，改成30
*d = 30
// c已经变成30了
fmt.Println(c)

改变内存中的值，会直接改变原来的变量值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 这个类似于值传递
func fn4(x int) {
	x = 10
}
// 这个类似于引用数据类型
func fn5(x *int) {
	*x = 20
}
func main() {
	x := 5
	fn4(x)
	fmt.Println(x)
	fn5(&x)
	fmt.Println(x)
}

我们创建了两个方法，一个是传入局部变量，一个是传入指针类型，最后运行得到的结果

1.4 new和make函数

需要注意的是，指针必须在创建内存后才可以使用，这个和 slice 和 map是一样的

1
2
3
4
5
6
7
8


// 引用数据类型map、slice等，必须使用make分配空间，才能够使用
var userInfo = make(map[string]string)
userInfo["userName"] = "zhangsan"
fmt.Println(userInfo)

var array = make([]int, 4, 4)
array[0] = 1
fmt.Println(array)

对于指针变量来说

1
2
3
4


// 指针变量初始化
var a *int
*a = 100
fmt.Println(a)

执行上面的代码会引发panic，为什么呢？在Go语言中对于引用类型的变量，我们在使用的时候不仅要声明它，还要为它分配内存空间，否则我们的值就没办法存储。而对于值类型的声明不需要分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。要分配内存，就引出来今天的new和make。Go 语言中new和make是内建的两个函数，主要用来分配内存。

这个时候，我们就需要使用new关键字来分配内存，new是一个内置的函数，它的函数签名如下：

1

func new(Type) *Type

其中

Type表示类型，new函数只接受一个参数，这个参数是一个类型
*Type表示类型指针，new函数返回一个指向该类型内存地址的指针

实际开发中new函数不太常用，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值。举个例子：

1
2
3
4
5
6
7


// 使用new关键字创建指针
aPoint := new(int)
bPoint := new(bool)
fmt.Printf("%T \n", aPoint)
fmt.Printf("%T \n", bPoint)
fmt.Println(*aPoint)
fmt.Println(*bPoint)

类似var a *int 只是声明了一个指针变量a但是没有初始化，指针作为引用类型需要初始化后才会拥有内存空间，才可以给它赋值。应该按照如下方式使用内置的

1.5 make和new的区别

两者都是用来做内存分配的；
make只能用于slice、map以及channel的初始化，返回的还是这三个引用类型的本身

而new用于类型的内存分配，并且内存初始的值为类型的零值，返回的是指向类型的指针

1

// int byte rune float bool string 这些类型都有默认零值；在变量声明的时候系统自动会分配一块内存空间； 而 point slice、map以及channel的零值是nil 系统不会默认分配空间，所以需要初始化；

1.6 指针易混淆示例

1.6.1 1. 函数传参指针

demo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


package main

import "fmt"

type T struct {
	Name string
}

func main() {
	var a = &T{}
	var b = &T{}
	fmt.Printf("a addr :%p,&a addr :%p, a: %v\n", a, &a, a)
	f1(a)
	fmt.Printf("a addr :%p, a: %v\n", a, a)
	fmt.Printf("b addr :%p, b: %v\n", b, b)
	f2(b)
	fmt.Printf("b addr :%p, b: %v\n", b, b)
}

func f1(t *T) {
	fmt.Printf("f1--t addr :%p, &t addr :%p:\n", t, &t)
	t = &T{
		Name: "aaaaaaaa",
	}
}

func f2(t *T) {
	fmt.Printf("f2--t addr :%p, &t addr :%p:\n", t, &t)
	*t = T{
		Name: "bbbbbbbb",
	}
}

/*
a addr :0x14000104210,&a addr :0x1400011c018, a: &{}
f1--t addr :0x14000104210, &t addr :0x1400011c028:
a addr :0x14000104210, a: &{}
b addr :0x14000104220, b: &{}
f2--t addr :0x14000104220, &t addr :0x1400011c030:
b addr :0x14000104220, b: &{bbbbbbbb}
*/

最终a没有发生改变，而b发生了改变；
- 在f1函数中，通过将t重新赋值为指向新的T结构体的指针，你改变了t的指针目标。这种方式只在函数内部有效，不会对原始指针产生影响。这是因为函数参数是按值传递的，当你将t重新赋值时，只是修改了函数内部的一个副本，不会影响原始指针。&a addr 是0x1400011c018，而f1中 &t addr :0x1400011c028；这两个对象不同；在main函数中调用f1(a)后，a的值仍然是原始的空指针，因为f1函数中的重新分配操作只影响了函数内部的t副本。
- 在f2函数中，通过解引用指针并修改解引用后的结构体的字段，你可以改变指针所指向的T结构体的内容。这种方式会影响原始指针，因为你直接修改了指针所指向的内存。

1.6.2 2. 函数传参数组