Go语言教程第六集 指针、引用和值类型

12 指针详解：在什么情况下应该使用指针？

这节课起我将带你学习本专栏的第三模块：深入理解 Go 语言。这部分主要会为你讲解 Go 语言的高级特性，以及 Go 语言一些特性功能的底层原理。通过这部分的学习，你不光可以更好地使用 Go 语言，还会更深入地理解 Go 语言，比如理解你所使用的 slice 底层是如何实现的等。

什么是指针

我们都知道程序运行时的数据是存放在内存中的，而内存会被抽象为一系列具有连续编号的存储空间，那么每一个存储在内存中的数据都会有一个编号，这个编号就是内存地址。有了这个内存地址就可以找到这个内存中存储的数据，而内存地址可以被赋值给一个指针。

小提示：内存地址通常为 16 进制的数字表示，比如 0x45b876。

可以总结为：在编程语言中，指针是一种数据类型，用来存储一个内存地址，该地址指向存储在该内存中的对象。这个对象可以是字符串、整数、函数或者你自定义的结构体。

小技巧：你也可以简单地把指针理解为内存地址。

举个通俗的例子，每本书中都有目录，目录上会有相应章节的页码，你可以把页码理解为一系列的内存地址，通过页码你可以快速地定位到具体的章节（也就是说，通过内存地址可以快速地找到存储的数据）。

指针的声明和定义

在 Go 语言中，获取一个变量的指针非常容易，使用取地址符 & 就可以，比如下面的例子：

ch12/main.go

func main() {
   name:="飞雪无情"
   nameP:=&name//取地址
   fmt.Println("name变量的值为:",name)
   fmt.Println("name变量的内存地址为:",nameP)
}

我在示例中定义了一个 string 类型的变量 name，它的值为"飞雪无情"，然后通过取地址符 & 获取变量 name 的内存地址，并赋值给指针变量 nameP，该指针变量的类型为 *string。运行以上示例你可以看到如下打印结果：

name变量的值为: 飞雪无情
name变量的内存地址为: 0xc000010200

这一串 0xc000010200 就是内存地址，这个内存地址可以赋值给指针变量 nameP。

指针类型非常廉价，只占用 4 个或者 8 个字节的内存大小。

以上示例中 nameP 指针的类型是 *string，用于指向 string 类型的数据。在 Go 语言中使用类型名称前加 * 的方式，即可表示一个对应的指针类型。比如 int 类型的指针类型是 *int，float64 类型的指针类型是 *float64，自定义结构体 A 的指针类型是 *A。总之，指针类型就是在对应的类型前加 * 号。

下面我通过一个图让你更好地理解普通类型变量、指针类型变量、内存地址、内存等之间的关系。

（指针变量、内存地址指向示意图）

上图就是我刚举的例子所对应的示意图，从图中可以看到普通变量 name 的值“飞雪无情”被放到内存地址为 0xc000010200 的内存块中。指针类型变量也是变量，它也需要一块内存用来存储值，这块内存对应的地址就是 0xc00000e028，存储的值是 0xc000010200。相信你已经看到关键点了，指针变量 nameP 的值正好是普通变量 name 的内存地址，所以就建立指向关系。

小提示：指针变量的值就是它所指向数据的内存地址，普通变量的值就是我们具体存放的数据。

不同的指针类型是无法相互赋值的，比如你不能对一个 string 类型的变量取地址然后赋值给 *int指针类型，编译器会提示你 Cannot use '&name' (type *string) as type *int in assignment。

此外，除了可以通过简短声明的方式声明一个指针类型的变量外，也可以使用 var 关键字声明，如下面示例中的 var intP *int 就声明了一个 *int 类型的变量 intP。

var intP *int
intP = &name //指针类型不同，无法赋值

可以看到指针变量也和普通的变量一样，既可以通过 var 关键字定义，也可以通过简短声明定义。

小提示：通过 var 声明的指针变量是不能直接赋值和取值的，因为这时候它仅仅是个变量，还没有对应的内存地址，它的值是 nil。

和普通类型不一样的是，指针类型还可以通过内置的 new 函数来声明，如下所示：

intP1:=new(int)

内置的 new 函数有一个参数，可以传递类型给它。它会返回对应的指针类型，比如上述示例中会返回一个 *int 类型的 intP1。

指针的操作

在 Go 语言中指针的操作无非是两种：一种是获取指针指向的值，一种是修改指针指向的值。

首先介绍如何获取，我用下面的代码进行演示：

nameV:=*nameP
fmt.Println("nameP指针指向的值为:",nameV)

可以看到，要获取指针指向的值，只需要在指针变量前加 * 号即可，获得的变量 nameV 的值就是“飞雪无情”，方法比较简单。

修改指针指向的值也非常简单，比如下面的例子：

*nameP = "公众号:飞雪无情" //修改指针指向的值
fmt.Println("nameP指针指向的值为:",*nameP)
fmt.Println("name变量的值为:",name)

对 *nameP 赋值等于修改了指针 nameP 指向的值。运行程序你将看到如下打印输出：

nameP指针指向的值为: 公众号:飞雪无情
name变量的值为: 公众号:飞雪无情

通过打印结果可以看到，不光 nameP 指针指向的值被改变了，变量 name 的值也被改变了，这就是指针的作用。因为变量 name 存储数据的内存就是指针 nameP 指向的内存，这块内存被 nameP 修改后，变量 name 的值也被修改了。

我们已经知道，通过 var 关键字直接定义的指针变量是不能进行赋值操作的，因为它的值为 nil，也就是还没有指向的内存地址。比如下面的示例：

var intP *int
*intP =10

运行的时候会提示 invalid memory address or nil pointer dereference。这时候该怎么办呢？其实只需要通过 new 函数给它分配一块内存就可以了，如下所示：

var intP *int = new(int)
//更推荐简短声明法，这里是为了演示
//intP:=new(int)

指针参数

假如有一个函数 modifyAge，想要用来修改年龄，如下面的代码所示。但运行它，你会看到 age 的值并没有被修改，还是 18，并没有变成 20。

age:=18
modifyAge(age)
fmt.Println("age的值为:",age)

func modifyAge(age int) {
age = 20
}

导致这种结果的原因是 modifyAge 中的 age 只是实参 age 的一份拷贝，所以修改它不会改变实参 age 的值。

如果要达到修改年龄的目的，就需要使用指针，现在对刚刚的示例进行改造，如下所示：

age:=18
modifyAge(&age)
fmt.Println("age的值为:",age)
func modifyAge(age *int)  {
   *age = 20
}

也就是说，当你需要在函数中通过形参改变实参的值时，需要使用指针类型的参数。

指针接收者

指针的接收者在“第 6 讲| struct 和 interface：结构体与接口都实现了哪些功能？”中有详细介绍，你可以再复习一下。对于是否使用指针类型作为接收者，有以下几点参考：

1. 如果接收者类型是 map、slice、channel 这类引用类型，不使用指针；

2. 如果需要修改接收者，那么需要使用指针；

3. 如果接收者是比较大的类型，可以考虑使用指针，因为内存拷贝廉价，所以效率高。

所以对于是否使用指针类型作为接收者，还需要你根据实际情况考虑。

什么情况下使用指针

从以上指针的详细分析中，我们可以总结出指针的两大好处：

1. 可以修改指向数据的值；

2. 在变量赋值，参数传值的时候可以节省内存。

不过 Go 语言作为一种高级语言，在指针的使用上还是比较克制的。它在设计的时候就对指针进行了诸多限制，比如指针不能进行运行，也不能获取常量的指针。所以在思考是否使用时，我们也要保持克制的心态。

我根据实战经验总结了以下几点使用指针的建议，供你参考：

1. 不要对 map、slice、channel 这类引用类型使用指针；

2. 如果需要修改方法接收者内部的数据或者状态时，需要使用指针；

3. 如果需要修改参数的值或者内部数据时，也需要使用指针类型的参数；

4. 如果是比较大的结构体，每次参数传递或者调用方法都要内存拷贝，内存占用多，这时候可以考虑使用指针；

5. 像 int、bool 这样的小数据类型没必要使用指针；

6. 如果需要并发安全，则尽可能地不要使用指针，使用指针一定要保证并发安全；

7. 指针最好不要嵌套，也就是不要使用一个指向指针的指针，虽然 Go 语言允许这么做，但是这会使你的代码变得异常复杂。

总结

为了使编程变得更简单，指针在高级的语言中被逐渐淡化，但是它也的确有自己的优势：修改数据的值和节省内存。所以在 Go 语言的开发中我们要尽可能地使用值类型，而不是指针类型，因为值类型可以使你的开发变得更简单，并且也是并发安全的。如果你想使用指针类型，就要参考我上面讲到的使用指针的条件，看是否满足，要在满足和必须的情况下才使用指针。

这节课到这里就要结束了，在这节课的最后同样给你留个思考题：指向接口的指针是否实现了该接口？为什么？思考后可以自己写代码验证下。

下节课将为你深入讲解值类型，引用类型，指针类型之间的关系和区别。

---

13 参数传递：值、引用及指针之间的区别？

上节课我留了一个思考题，关于指向接口的指针的思考。在“第 6 讲| struct 和 interface：结构体与接口都实现了哪些功能？”中，你已经知道了如何实现一个接口，并且也知道如果值接收者实现了接口，那么值的指针也就实现了该接口。现在我们再一起来复习一下接口实现的知识，然后再解答关于指向接口的指针的思考题。

在下面的代码中，值类型 address 作为接收者实现了接口 fmt.Stringer，那么它的指针类型 *address 也就实现了接口 fmt.Stringer。

ch13/main.go

type address struct {
   province string
   city string
}
func (addr address) String()  string{
   return fmt.Sprintf("the addr is %s%s",addr.province,addr.city)
}

在下面的代码示例中，我定义了值类型的变量 add，然后把它和它的指针 &add 都作为参数传给函数 printString，发现都是可以的，并且代码可以成功运行。这也证明了当值类型作为接收者实现了某接口时，它的指针类型也同样实现了该接口。

ch13/main.go

func main() {
   add := address{province: "北京", city: "北京"}
   printString(add)
   printString(&add)
}
func printString(s fmt.Stringer) {
   fmt.Println(s.String())
}

基于以上结论，我们继续分析，看是否可以定义一个指向接口的指针。如下所示：

ch13/main.go

var si fmt.Stringer =address{province: "上海",city: "上海"}
printString(si)
sip:=&si
printString(sip)

在这个示例中，因为类型 address 已经实现了接口 fmt.Stringer，所以它的值可以被赋予变量 si，而且 si 也可以作为参数传递给函数 printString。

接着你可以使用 sip:=&si 这样的操作获得一个指向接口的指针，这是没有问题的。不过最终你无法把指向接口的指针 sip 作为参数传递给函数 printString，Go 语言的编译器会提示你如下错误信息：

./main.go:42:13: cannot use sip (type *fmt.Stringer) as type fmt.Stringer in argument to printString:
	*fmt.Stringer is pointer to interface, not interface

于是可以总结为：虽然指向具体类型的指针可以实现一个接口，但是指向接口的指针永远不可能实现该接口。

所以你几乎从不需要一个指向接口的指针，把它忘掉吧，不要让它在你的代码中出现。

通过这个思考题，相信你也对 Go 语言的值类型、引用类型和指针等概念有了一定的了解，但可能也存在一些迷惑。这节课我将更深入地分析这些概念。

修改参数

假设你定义了一个函数，并在函数里对参数进行修改，想让调用者可以通过参数获取你最新修改的值。我仍然以前面课程用到的 person 结构体举例，如下所示：

ch13/main.go

func main() {
   p:=person{name: "张三",age: 18}
   modifyPerson(p)
   fmt.Println("person name:",p.name,",age:",p.age)
}
func modifyPerson(p person)  {
   p.name = "李四"
   p.age = 20
}
type person struct {
   name string
   age int
}

在这个示例中，我期望通过 modifyPerson 函数把参数 p 中的 name 修改为李四，把 age 修改为 20 。代码没有错误，但是运行一下，你会看到如下打印输出：

person name: 张三 ,age: 18

怎么还是张三与 18 呢？我换成指针参数试试，因为在上节课中我们已经知道可以通过指针修改指向的对象数据，如下所示：

modifyPerson(&p)
func modifyPerson(p *person)  {
   p.name = "李四"
   p.age = 20
}

这些代码用于满足指针参数的修改，把接收的参数改为指针参数，以及在调用 modifyPerson 函数时，通过&取地址符传递一个指针。现在再运行程序，就可以看到期望的输出了，如下所示：

person name: 李四 ,age: 20

值类型

在上面的小节中，我定义的普通变量 p 是 person 类型的。在 Go 语言中，person 是一个值类型，而 &p 获取的指针是 *person 类型的，即指针类型。那么为什么值类型在参数传递中无法修改呢？这也要从内存讲起。

在上节课中，我们已经知道变量的值是存储在内存中的，而内存都有一个编号，称为内存地址。所以要想修改内存中的数据，就要找到这个内存地址。现在，我来对比值类型变量在函数内外的内存地址，如下所示：

ch13/main.go

func main() {
   p:=person{name: "张三",age: 18}
   fmt.Printf("main函数：p的内存地址为%p\n",&p)
   modifyPerson(p)
   fmt.Println("person name:",p.name,",age:",p.age)
}
func modifyPerson(p person)  {
   fmt.Printf("modifyPerson函数：p的内存地址为%p\n",&p)
   p.name = "李四"
   p.age = 20
}

其中，我把原来的示例代码做了更改，分别打印出在 main 函数中变量 p 的内存地址，以及在 modifyPerson 函数中参数 p 的内存地址。运行以上程序，可以看到如下结果：

main函数：p的内存地址为0xc0000a6020
modifyPerson函数：p的内存地址为0xc0000a6040
person name: 张三 ,age: 18

你会发现它们的内存地址都不一样，这就意味着，在 modifyPerson 函数中修改的参数 p 和 main 函数中的变量 p 不是同一个，这也是我们在 modifyPerson 函数中修改参数 p，但是在 main 函数中打印后发现并没有修改的原因。

导致这种结果的原因是 Go 语言中的函数传参都是值传递。 值传递指的是传递原来数据的一份拷贝，而不是原来的数据本身。

（main 函数调用 modifyPerson 函数传参内存示意图）

以 modifyPerson 函数来说，在调用 modifyPerson 函数传递变量 p 的时候，Go 语言会拷贝一个 p 放在一个新的内存中，这样新的 p 的内存地址就和原来不一样了，但是里面的 name 和 age 是一样的，还是张三和 18。这就是副本的意思，变量里的数据一样，但是存放的内存地址不一样。

除了 struct 外，还有浮点型、整型、字符串、布尔、数组，这些都是值类型。

指针类型

指针类型的变量保存的值就是数据对应的内存地址，所以在函数参数传递是传值的原则下，拷贝的值也是内存地址。现在对以上示例稍做修改，修改后的代码如下：

func main() {
   p:=person{name: "张三",age: 18}
   fmt.Printf("main函数：p的内存地址为%p\n",&p)
   modifyPerson(&p)
   fmt.Println("person name:",p.name,",age:",p.age)
}
func modifyPerson(p *person)  {
   fmt.Printf("modifyPerson函数：p的内存地址为%p\n",p)
   p.name = "李四"
   p.age = 20
}

运行这个示例，你会发现打印出的内存地址一致，并且数据也被修改成功了，如下所示：

main函数：p的内存地址为0xc0000a6020
modifyPerson函数：p的内存地址为0xc0000a6020
person name: 李四 ,age: 20

所以指针类型的参数是永远可以修改原数据的，因为在参数传递时，传递的是内存地址。

小提示：值传递的是指针，也是内存地址。通过内存地址可以找到原数据的那块内存，所以修改它也就等于修改了原数据。

引用类型

下面要介绍的是引用类型，包括 map 和 chan。

map

对于上面的例子，假如我不使用自定义的 person 结构体和指针，能不能用 map 达到修改的目的呢？

下面我来试验一下，如下所示：

ch13/main.go

func main() {
   m:=make(map[string]int)
   m["飞雪无情"] = 18
   fmt.Println("飞雪无情的年龄为",m["飞雪无情"])
   modifyMap(m)
   fmt.Println("飞雪无情的年龄为",m["飞雪无情"])
}
func modifyMap(p map[string]int)  {
   p["飞雪无情"] =20
}

我定义了一个 map[string]int 类型的变量 m，存储一个 Key 为飞雪无情、Value 为 18 的键值对，然后把这个变量 m 传递给函数 modifyMap。modifyMap 函数所做的事情就是把对应的值修改为 20。现在运行这段代码，通过打印输出来看是否修改成功，结果如下所示：

飞雪无情的年龄为 18
飞雪无情的年龄为 20

确实修改成功了。你是不是有不少疑惑？没有使用指针，只是用了 map 类型的参数，按照 Go 语言值传递的原则，modifyMap 函数中的 map 是一个副本，怎么会修改成功呢？

要想解答这个问题，就要从 make 这个 Go 语言内建的函数说起。在 Go 语言中，任何创建 map 的代码（不管是字面量还是 make 函数）最终调用的都是 runtime.makemap 函数。

小提示：用字面量或者 make 函数的方式创建 map，并转换成 makemap 函数的调用，这个转换是 Go 语言编译器自动帮我们做的。

从下面的代码可以看到，makemap 函数返回的是一个 *hmap 类型，也就是说返回的是一个指针，所以我们创建的 map 其实就是一个 *hmap。

src/runtime/map.go

// makemap implements Go map creation for make(map[k]v, hint).
func makemap(t *maptype, hint int, h *hmap) *hmap{
  //省略无关代码
}

因为 Go 语言的 map 类型本质上就是 *hmap，所以根据替换的原则，我刚刚定义的 modifyMap(p map) 函数其实就是 modifyMap(p *hmap)。这是不是和上一小节讲的指针类型的参数调用一样了？这也是通过 map 类型的参数可以修改原始数据的原因，因为它本质上就是个指针。

为了进一步验证创建的 map 就是一个指针，我修改上述示例，打印 map 类型的变量和参数对应的内存地址，如下面的代码所示：

func main(){
  //省略其他没有修改的代码
  fmt.Printf("main函数：m的内存地址为%p\n",m)
}
func modifyMap(p map[string]int)  {
   fmt.Printf("modifyMap函数：p的内存地址为%p\n",p)
   //省略其他没有修改的代码
}

例子中的两句打印代码是新增的，其他代码没有修改，这里就不再贴出来了。运行修改后的程序，你可以看到如下输出：

飞雪无情的年龄为 18
main函数：m的内存地址为0xc000060180
modifyMap函数：p的内存地址为0xc000060180
飞雪无情的年龄为 20

从输出结果可以看到，它们的内存地址一模一样，所以才可以修改原始数据，得到年龄是 20 的结果。而且我在打印指针的时候，直接使用的是变量 m 和 p，并没有用到取地址符 &，这是因为它们本来就是指针，所以就没有必要再使用 & 取地址了。

所以在这里，Go 语言通过 make 函数或字面量的包装为我们省去了指针的操作，让我们可以更容易地使用 map。其实就是语法糖，这是编程界的老传统了。

注意：这里的 map 可以理解为引用类型，但是它本质上是个指针，只是可以叫作引用类型而已。在参数传递时，它还是值传递，并不是其他编程语言中所谓的引用传递。

chan

还记得我们在 Go 语言并发模块中学的 channel 吗？它也可以理解为引用类型，而它本质上也是个指针。

通过下面的源代码可以看到，所创建的 chan 其实是个 *hchan，所以它在参数传递中也和 map 一样。

func makechan(t *chantype, size int64) *hchan {
    //省略无关代码
}

严格来说，Go 语言没有引用类型，但是我们可以把 map、chan 称为引用类型，这样便于理解。除了 map、chan 之外，Go 语言中的函数、接口、slice 切片都可以称为引用类型。

小提示：指针类型也可以理解为是一种引用类型。

类型的零值

在 Go 语言中，定义变量要么通过声明、要么通过 make 和 new 函数，不一样的是 make 和 new 函数属于显式声明并初始化。如果我们声明的变量没有显式声明初始化，那么该变量的默认值就是对应类型的零值。

从下面的表格可以看到，可以称为引用类型的零值都是 nil。

(各种类型的零值)

总结

在 Go 语言中，函数的参数传递只有值传递，而且传递的实参都是原始数据的一份拷贝。如果拷贝的内容是值类型的，那么在函数中就无法修改原始数据；如果拷贝的内容是指针（或者可以理解为引用类型 map、chan 等），那么就可以在函数中修改原始数据。

所以我们在创建一个函数的时候，要根据自己的真实需求决定参数的类型，以便更好地服务于我们的业务。

这节课中，我讲解 chan 的时候没有举例，你自己可以自定义一个有 chan 参数的函数，作为练习题。

下节课我将介绍“内存分配：new 还是 make？什么情况下该用谁？”记得来听课！

---