2.12 值类型和引用类型

在 Go 语言中，数据类型可以分为两大类：值类型（Value Types）和引用类型（Reference Types）。

理解这两种类型的区别对于理解 Go 中的数据传递和内存管理是很重要的。

一、内存模型

Go 在内存分配上有两个主要的区域：栈（stack）和堆（heap）。栈用于存储函数调用时的局部变量和函数参数，特点是分配和回收速度快。而堆则用于存储那些可能需要跨函数存活的数据，由垃圾回收器管理。

二、值类型

值类型的变量直接存储数据值，当进行赋值或传参时，会复制整个数据。

值类型包括

• 基本数据类型：int、float64、bool、string
• 数组：[5]int
• 结构体：struct

值类型有以下特点

• 直接存储值，不存储地址。
• 变量间赋值或作为函数参数传递时进行值复制。
• 值类型的变量副本是独立的，修改一个变量的副本不会影响另一个。
• 值类型的复制会涉及整个值的拷贝，因此对于大的结构体或数组，复制操作可能会较慢。
• 值类型通常在栈上分配，除非是通过 new 函数分配的，或者是作为闭包中的变量被分配到堆上。

简单的示例

package main

import "fmt"

func main() {
    x := 10
    y := x
    x++
    fmt.Println(x, y) // 输出：11 10

    numbers := [3]int{1, 2, 3}
    numbers2 := numbers
    numbers2[0] = 1000
    fmt.Println(numbers) // 输出：[1 2 3]   
    fmt.Println(numbers2) // 输出：[1000 2 3]
}

在这个例子中，x 和 y 都是整型值，y 是 x 的一个副本。对 x 的修改不会影响到 y，因此 y 的值仍然是10。

三、引用类型

引用类型并不直接存储数据本身，而是存储指向数据的指针，当复制一个引用类型的变量时，复制的是指针，新旧变量将指向相同的底层数据。

引用类型包括

• 切片（Slices）：切片是对数组的封装，提供了一个灵活、动态的视图。当修改切片中的元素时，实际上是在修改底层数组的相应元素。
• 映射（Maps）：映射是一种存储键值对的集合。将映射传递给一个函数或者赋值给另一个变量时，任何对映射的修改都会反映在所有引用了这个映射的地方。
• 通道（Channels）：通道用于在不同的 goroutine 之间传递消息。通道本质上是引用类型，当复制或传递它们时，实际上传递的是对通道数据结构的引用。
• 接口（Interfaces）：接口类型是一种抽象类型，定义了一组方法，但不会实现这些方法。接口内部存储的是指向实现了接口方法的值的指针和指向该类型信息的指针。
• 函数（Functions）：在 Go 中，函数也是一种引用类型。当把一个函数赋给另一个变量时，实际上是在复制一个指向该函数的引用。

引用类型有以下特点

存储的是指向数据的地址，而不是数据本身。 当引用类型的变量被赋值或作为函数参数传递时，实际上是将该地址复制一份，因此多个变量可能共享同一份数据。 引用类型的数据通常在堆上分配，即使变量本身在栈上。 引用类型的零值是 nil，一个未初始化的引用类型的变量将会是 nil，不指向任何内存地址。

简单的示例

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3}
    numbers2 := numbers
    numbers2[0] = 1000
    fmt.Println(numbers) // 输出：[1000 2 3]
    fmt.Println(numbers2) // 输出：[1000 2 3]
}

四、内存分配机制

1. 栈内存 vs 堆内存

func memoryAllocation() {
    // 值类型通常分配在栈上（小对象）
    var num int = 42        // 栈分配
    var arr [10]int         // 栈分配（小数组）
    
    // 引用类型的数据通常分配在堆上
    slice := make([]int, 100)     // 底层数组在堆上
    m := make(map[string]int)     // 映射数据在堆上
    
    // 大对象可能逃逸到堆上
    var bigArray [10000]int       // 可能在堆上
    
    fmt.Printf("num地址: %p\n", &num)
    fmt.Printf("slice地址: %p\n", &slice)
    fmt.Printf("map地址: %p\n", &m)
    fmt.Printf("bigArray地址: %p\n", &bigArray)
}

2. 零值行为

func zeroValueExample() {
    // 值类型的零值是具体的值
    var i int           // 0
    var f float64       // 0.0
    var b bool          // false
    var s string        // ""
    
    // 引用类型的零值是 nil
    var slice []int     // nil
    var m map[string]int // nil
    var ptr *int        // nil
    var ch chan int     // nil
    
    fmt.Printf("值类型零值: %d, %f, %t, %q\n", i, f, b, s)
    fmt.Printf("引用类型零值: %v, %v, %v, %v\n", slice, m, ptr, ch)
    
    // 使用前需要初始化
    slice = make([]int, 0)
    m = make(map[string]int)
    ch = make(chan int)
}

五、在函数传递中的差异

Go里边函数传参只有值传递一种方式。在函数参数传递时，值类型和引用类型的行为也不同。值类型参数在传递给函数时会创建一个副本，而引用类型参数传递的是指针的副本，所以函数内部对引用类型参数的修改会影响原始数据。

package main

import "fmt"

func modifySlice(s []int) {
    // 切片是引用类型，传递的是切片头的副本，底层数组共享
    s[0] = 100
}

func main() {
    s := []int{1, 2, 3}
    modifySlice(s)
    fmt.Println(s) // 输出 [100 2 3], 切片被修改了
}

六、指针类型（Pointer Types）

指针类型也是 Golang 中的一种基本类型，存储了值的内存地址。指针类型可以指向任何值类型的数据，并且通过指针，可以在不同的函数之间共享和修改数据。

package main

import "fmt"

func modifyValue(p *int) {
    *p = 100
}

func main() {
    a := 1
    modifyValue(&a)
    fmt.Println(a) // 输出 100, 值被修改了
}

七、值类型与引用类型的比较

• 内存分配：值类型在声明或初始化时即分配内存，引用类型仅在声明指针或容器时分配内存，而所指向的数据通常在首次使用时动态分配。
• 内存占用：值类型的每次复制都会产生新的数据副本，可能会消耗更多内存；引用类型在多处共享数据时只需存储数据一次，节省内存。
• 数据安全性：值类型在函数调用过程中保证了数据的隔离性，不易出现并发问题；引用类型在并发环境下的数据共享可能导致竞态条件，需要额外同步机制来保护。
• 性能考虑：由于不存在共享数据的问题，值类型的计算相对简单，有时性能更好；然而，在需要大量数据共享或动态扩容缩容的场景下，引用类型更具有优势。