Golang基础笔记七之指针，值类型和引用类型

本文首发于公众号：Hunter后端
原文链接：Golang基础笔记七之指针，值类型和引用类型

本篇笔记介绍 Golang 里的指针，值类型与引用类型相关的概念，以下是本篇笔记目录：

• 指针
  
• 值类型与引用类型
  
• 内存逃逸
  
• 减少内存逃逸的几种方案
  

1、指针

在计算机内存中，每个变量都存储在特定的内存地址上，而指针是一种特殊的变量，它存储的是一个变量的内存地址。
我们可以通过指针访问变量的内存地址，也可以通过指针访问或修改这个变量的内存地址存储的值。
1. 指针的声明与初始化

使用 & 符号来获取变量的内存地址，使用 * 获取指针指向的内存地址的值：

1. var a int = 10
2. var a_ptr *int = &a
3. fmt.Println("a 的内存地址是: ", &a)
4. fmt.Println("a_ptr 的值是: ", a_ptr)
5. fmt.Println("根据指针获取的值是: ", *a_ptr)

复制代码

2. 指针操作

使用 * 获取变量指向的内存地址的值后，可以直接使用，也可以对其进行修改，在上面操作后，我们接着操作：

1. *a_ptr = 20
2. fmt.Println("修改后 a 的值是: ", a)

复制代码

可以看到，通过指针修改后，a 的值已经变成了 20。
3. 指针作为函数传参

如果我们将指针作为函数的参数传入，并且在函数内部对其进行了修改，那么会直接修改指针所指向的变量的值，下面是一个示例：

1. func ModityValue(ptr *int) {
2.     *ptr = 20
3. }
5. func main() {
6.     var a int = 10
7.     fmt.Println("修改前, a 的值是：", a)  // 修改前, a 的值是： 10
8.     ModityValue(&a)
9.     fmt.Println("修改后, a 的值是：", a)  // 修改后, a 的值是： 20
10. }

复制代码

2、值类型与引用类型

1. 值类型与引用类型包括的数据类型

值类型包括整型、浮点型、布尔型、字符串、数组、结构体等，值类型的变量直接存储值，内存通常分配在栈上。
引用类型包括切片、映射、通道等，引用类型的变量存储的是一个引用（内存地址），内存通常分配在堆上。
2. 栈和堆

值类型的变量通常分配在栈上，引用类型的变量通常分配在堆上，注意，这里是通常，还会有特殊情况后面再介绍。
先来介绍一下栈和堆。
1) 栈

先介绍一下栈相关的信息：

• 栈内存由编译器自动管理，在函数调用时分配，函数返回后立即释放，效率极高
  
• 栈上变量的生命周期严格限定在函数执行期间。函数调用开始，变量被创建并分配内存；函数调用结束，变量占用的内存会被立即回收
  

2) 堆

• 堆用于存储程序运行期间动态分配的内存，其分配和释放不是由函数调用的生命周期决定，而是由程序员或垃圾回收机制来管理。
  
• 堆上的变量生命周期不依赖于函数调用的结束，变量可以在函数调用结束后仍然存在，直到没有任何引用指向它，然后由垃圾回收机制进行回收。
  

3. 值类型与引用类型的内存分配

值类型变量通常具有明确的生命周期，通常与其所在的函数调用相关，函数调用结束后，这些变量占用的内存可以立即被回收，使用栈来存储值类型可以充分利用栈的高效内存管理机制。
而引用类型的变量需要动态分配内存，并且其生命周期可能超出函数调用的范围，比如切片可以动态调整大小，映射也可以增减键值对，这些操作需要在运行时进行内存的分配和释放，使用堆来存储引用类型可以更好地支持这些动态特性。
前面介绍值类型通常会被分配到栈上，但是也有可能被分配到堆上，这种情况就是内存逃逸。
内存逃逸的内容在下一个小节中再介绍。
4. 值类型和引用类型的复制

值类型的复制会复制整个数据，是深拷贝的操作，副本的修改不会影响到原始数据，比如下面的操作：

1. type Person struct {
2.     Name string
3.     Age  int
4. }
6. func main() {
7.     p := Person{Name: "Hunter", Age: 18}
8.     p2 := p
9.     p2.Name = "Tom"
10.     fmt.Printf("p1 name is:%s, p2 name is:%s \n", p.Name, p2.Name)
11.     // p1 name is:Hunter, p2 name is:Tom
12. }

复制代码

而引用类型的复制则复制的是其引用，属于浅拷贝的操作，多个变量会共享底层数据，修改其中一个副本会影响原始数据，比如下面的操作：

1.     s := []int{1, 2, 3}
2.     s2 := s
3.     s2[1] = 8
5.     fmt.Println("s:", s)  // s: [1 8 3]
6.     fmt.Println("s2:", s2)  // s2: [1 8 3]

复制代码

5. 值类型和引用类型的函数传参

值类型和引用类型的函数传参和复制一样，值类型传递的是变量的副本，在函数内部修改不会影响原始变量，而引用类型传递的是原始数据的引用，函数内部修改会影响外部变量。
下面是值类型的函数传参的示例：

1. func ChangePerson(p Person) {
2.     p.Name = "Tom"
3.     fmt.Println("inner func p.Name is:", p.Name)
4.     // inner func p.Name is: Tom
5. }
7. func main() {
8.     p := Person{Name: "Hunter", Age: 18}
9.     ChangePerson(p)
10.     fmt.Println("outer func p.Name is:", p.Name)
11.     // outer func p.Name is: Hunter
12. }

复制代码

以下是引用类型传参的示例：

1. func ChangeSlice(s []int) {
2.     s[2] = 9
3.     fmt.Println("inner func slice is:", s)
4.     // inner func slice is: [1 2 9]
5. }
6. func main() {
7.     s := []int{1, 2, 3}
8.     ChangeSlice(s)
9.     fmt.Println("outer func slice is:", s)
10.     // outer func slice is: [1 2 9]
11. }

复制代码

对于函数传参，还有两点需要注意，一个是值类型函数传参的性能问题，一个是引用类型涉及扩容的问题。
1) 值类型函数传参的性能问题

对于值类型变量，比如一个结构体，拥有非常多的字段，当其作为函数传参，传递的会是变量的副本，也就是会将其值复制出来传递，那么当这个变量非常大的时候可能就会涉及性能问题。
为了解决这个问题，有个方法就是传递其变量的指针，但是需要注意传递指针在函数内部对其修改后，会影响到原始变量的值。
2) 引用类型函数传参扩容问题

当引用类型作为函数传参，如果在函数内部修改涉及到扩容，那么其地址就会更改，那么函数内部的修改就不会反映到其原值上了，比如下面这个是切片在函数内部修改的示例：

1. func ChangeSlice(s []int) {
2.     s = append(s, []int{4, 5, 6}...)
3.     fmt.Println("inner func slice is:", s)
4.     // inner func slice is: [1 2 3 4 5 6]
5. }
7. func main() {
8.     s := []int{1, 2, 3}
9.     ChangeSlice(s)
10.     fmt.Println("outer func slice is:", s)
11.     // outer func slice is: [1 2 3]
12. }

复制代码

3、内存逃逸

Golang 里编译器决定内存分配位置是在栈上还是在堆上，这个就是逃逸分析，这个过程发生在编译阶段。
1. 逃逸分析的方法

我们可以使用下面的命令来查看逃逸分析的结果：

1.  go build -gcflags="-m" main.go

复制代码

2. 内存逃逸的场景

内存逃逸可能会存在于以下这些情况，比如函数返回一个值类型变量的指针，或者闭包引用局部变量等。
1) 函数返回局部变量的指针

如果一个函数返回值是变量的指针，那么该局部变量会逃逸到堆上：

1. func CreateInt() *int {
2.     x := 1
3.     return &x
4. }
5. func main() {
6.     _ = CreateInt()
7. }

复制代码

使用逃逸分析的命令：

1.  go build -gcflags="-m" main.go

复制代码

可以看到输出如下：

1. # command-line-arguments
2. ./main.go:14:2: moved to heap: x

复制代码

说明 x 这个变量会逃逸到堆上。
2) 闭包引用局部变量

如果闭包引用了函数的局部变量，这些局部变量会逃逸到堆上，因为闭包可能在函数调用结束后继续存在并访问这些变量：

1. func counter() func() int {
2.     count := 0
3.     return func() int {
4.         count++
5.         return count
6.     }
7. }
8. func main() {
9.     _ = counter()
10. }

复制代码

对此使用逃逸分析的命令，输出结果如下：

1. # command-line-arguments
2. ./main.go:14:2: moved to heap: count
3. ./main.go:15:9: func literal escapes to heap

复制代码

3) 向接口类型变量赋值

当我们将值赋给接口类型的变量，因为接口类型需要再运行时才能确定具体的类型，所以这个值也会逃逸到堆上，最常见的一个例子就是 fmt.Println()：

1. func main() {
2.     s := "hello world"
3.     fmt.Println(s)
4. }

复制代码

其逃逸分析结果如下：

1. # command-line-arguments
2. ./main.go:25:13: ... argument does not escape
3. ./main.go:25:14: s escapes to heap

复制代码

除此之外，还有一些原因也可能造成内存逃逸，比如大对象超出了栈容量限制，被强制分配到堆、发送变量到 channel 等。
3. 逃逸分析的意义

内存逃逸就是原本分配在栈上的变量被分配到了堆上，而分配到堆上的变量在函数调用结束后仍然存在，直到没有任何引用指向它，然后由垃圾回收机制进行回收。
所以通过逃逸分析，我们可以减轻GC（垃圾回收）的压力。
4、减少内存逃逸的几种方案

• 减少堆分配，避免函数不必要的指针返回，优先通过返回值传递小对象
  
• 避免闭包引用局部变量
  
• 减少使用向接口类型赋值，如 fmt.Println() 这种
  
• 避免大对象超出栈容量限制
  

来源：豆瓜网用户自行投稿发布，如果侵权，请联系站长删除