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

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

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

一、 关于指针

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

二、 指针地址和指针类型

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

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

举个例子：
Go中的指针 - 图2

三、 指针取值

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

  1. // 指针取值
  2. var c = 20
  3. // 得到c的地址，赋值给d
  4. var d = &c
  5. // 打印d的值，也就是c的地址
  6. fmt.Println(d)
  7. // 取出d指针所对应的值
  8. fmt.Println(*d)
  9. // c对应地址的值，改成30
  10. *d = 30
  11. // c已经变成30了
  12. fmt.Println(c)

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

  1. // 这个类似于值传递
  2. func fn4(x int) {
  3.     x = 10
  4. }
  5. // 这个类似于引用数据类型
  6. func fn5(x *int) {
  7.     *x = 20
  8. }
  9. func main() {
  10.     x := 5
  11.     fn4(x)
  12.     fmt.Println(x)
  13.     fn5(&x)
  14.     fmt.Println(x)
  15. }

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

  1. 5
  2. 20

ed
py to clipboardErrorCopied

四、 new和make函数

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

  1. // 引用数据类型map、slice等，必须使用make分配空间，才能够使用
  2. var userInfo = make(map[string]string)
  3. userInfo["userName"] = "zhangsan"
  4. fmt.Println(userInfo)
  6. var array = make([]int, 4, 4)
  7. array[0] = 1
  8. fmt.Println(array)

对于指针变量来说

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

执行上面的代码会引发panic，为什么呢？

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

New

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

  1. func new(Type) *Type

其中

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

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

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

本节开始的示例代码中var a *int只是声明了一个指针变量a但是没有初始化，指针作为引用类型需要初始化后才会拥有内存空间，才可以给它赋值。应该按照如下方式使用内置的new函数对a进行初始化之后就可以正常对其赋值了：

  1. func main() {
  2.     var a *int
  3.     a = new(int)
  4.     *a = 10
  5.     fmt.Println(*a)
  6. }

make

make也是用于内存分配的，区别于new，它只用于slice、map以及chan的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。make函数的函数签名如下：

  1. func make(t Type, size ...IntegerType) Type

make函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作。这个我们在上一章中都有说明，关于channel我们会在后续的章节详细说明。
本节开始的示例中var b map[string]int只是声明变量b是一个map类型的变量，需要像下面的示例代码一样使用make函数进行初始化操作之后，才能对其进行键值对赋值：

  1. func main() {
  2.     var b map[string]int
  3.     b = make(map[string]int, 10)
  4.     b["沙河娜扎"] = 100
  5.     fmt.Println(b)
  6. }

五、 make和new的区别

  • 两者都是用来做内存分配的
  • make只能用于slice、map以及channel的初始化，返回的还是这三个引用类型的本身
  • 而new用于类型的内存分配，并且内存赌赢的值为类型的零值，返回的是指向类型的指针