9.3 指针和内存分配详解

定义

了解指针之前，先讲一下什么是变量。

每当我们编写任何程序时，我们都需要在内存中存储一些数据/信息。数据存储在特定地址的存储器中。内存地址看起来像0xAFFFF（这是内存地址的十六进制表示）。

现在，要访问数据，我们需要知道存储它的地址。我们可以跟踪存储与程序相关的数据的所有内存地址。但想象一下，记住所有内存地址并使用它们访问数据会有非常困难。这就是为什么引入变量。

变量是一种占位符，用于引用计算机的内存地址，可理解为内存地址的标签。

什么是指针

指针是存储另一个变量的内存地址的变量。所以指针也是一种变量，只不过它是一种特殊变量，它的值存放的是另一个变量的内存地址。

指针内存分配详解 - 图1

在上面的例子中，指针p包含值0x0001，该值是变量的地址a。

Go类型占用内存情况

unsafe包可以获取变量的内存使用情况

Go语言提供以下基本数字类型：

无符号整数 uint8，uint16，uint32，uint64

符号整数 int8，int16，int32，int64

实数 float32，float64 Predeclared

整数(依赖系统类型，跟系统有关) uint，int，uintptr （指针）

32位系统

uint=uint32 int=int32 uintptr为32位的指针

64位系统

uint=uint64 int=int64 uintptr为64位的指针

示例：

  1. package main
  3. import (
  4.    "fmt"
  5.    "unsafe"
  6. )
  8. func main() {
  9.    var uint8Value uint8
  10.    var uint16Value uint16
  11.    var uint32Value uint32
  12.    var uint64Value uint64
  13.    var int8Value int8
  14.    var int16Value int16
  15.    var int32Value int32
  16.    var int64Value int64
  18.    var float32Value float32
  19.    var float64Value float64
  21.    fmt.Println("uint8Value = Size:", unsafe.Sizeof(uint8Value)) //uint8Value = Size: 1
  22.    fmt.Println("uint16Value = Size:", unsafe.Sizeof(uint16Value)) //uint16Value = Size: 2
  23.    fmt.Println("uint32Value = Size:", unsafe.Sizeof(uint32Value)) //uint32Value = Size: 4
  24.    fmt.Println("uint64Value = Size:", unsafe.Sizeof(uint64Value))// uint64Value = Size: 8
  26.    fmt.Println("int8Value = Size:", unsafe.Sizeof(int8Value)) //int8Value = Size: 1
  27.    fmt.Println("int16Value = Size:", unsafe.Sizeof(int16Value))//int16Value = Size: 2
  28.    fmt.Println("int32Value = Size:", unsafe.Sizeof(int32Value))//int32Value = Size: 4
  29.    fmt.Println("int64Value = Size:", unsafe.Sizeof(int64Value)) //int64Value = Size: 8
  31.    fmt.Println("float32Value = Size:", unsafe.Sizeof(float32Value)) //float32Value = Size: 4
  32.    fmt.Println("float64Value = Size:", unsafe.Sizeof(float64Value))//float64Value = Size: 8
  34. }

上面的是基本类型，接下来了解下复杂类型，以结构体类型为例

  1. type Example struct {
  2.    BoolValue  bool
  3.    IntValue   int16
  4.    FloatValue float32
  5. }

该结构代表复杂类型。它代表7个字节，带有三个不同的数字表示。bool是一个字节，int16是2个字节，float32增加4个字节。但是，在此结构的内存中实际分配了8个字节。

所有内存都分配在对齐边界上，以最大限度地减少内存碎片整理。要确定对齐边界Go用于您的体系结构，您可以运行unsafe.Alignof函数。Go为64bit Darwin平台的对齐边界是8个字节。因此，当Go确定结构的内存分配时，它将填充字节以确保最终内存占用量是8的倍数。编译器将确定添加填充的位置。

什么是内存对齐呢？

内存对齐，也叫边界对齐（boundary alignment)，是处理器为了提高处理性能而对存取数据的起始地址所提出的一种要求。编译器为了使我们编写的C程序更有效，就必须最大限度地满足处理器对边界对齐的要求。

指针内存分配详解 - 图2

从处理器的角度来看，需要尽可能减少对内存的访问次数以实现对数据结构进行更加高效的操作。为什么呢？因为尽管处理器包含了缓存，但它在处理数据时还得读取缓存中的数据，读取缓存的次数当然是越少越好！如上图所示，在采用边界对齐的情况下，当处理器需要访问a变量和b变量时都只需进行一次存取（图中花括号表示一次存取操作）。若不采用边界对齐，a变量只要一次处理器操作，而b变量却至少要进行两次操作。对于b_,处理器还得调用更多指令将其合成一个完整的4字节，这样无疑大大降低了程序效率。

以下程序显示Go插入到Example类型struct的内存占用中的填充：

  1. package main
  3. import (
  4.    "fmt"
  5.    "unsafe"
  6. )
  8. type Example struct {
  9.    BoolValue  bool
  10.    IntValue   int16
  11.    FloatValue float32
  12. }
  14. func main() {
  15.    example := &Example{
  16.       BoolValue:  true,
  17.       IntValue:   10,
  18.       FloatValue: 3.141592,
  19.    }
  21.    exampleNext := &Example{
  22.       BoolValue:  true,
  23.       IntValue:   10,
  24.       FloatValue: 3.141592,
  25.    }
  27.    alignmentBoundary := unsafe.Alignof(example)
  29.    sizeBool := unsafe.Sizeof(example.BoolValue)
  30.    offsetBool := unsafe.Offsetof(example.BoolValue)
  32.    sizeInt := unsafe.Sizeof(example.IntValue)
  33.    offsetInt := unsafe.Offsetof(example.IntValue)
  35.    sizeFloat := unsafe.Sizeof(example.FloatValue)
  36.    offsetFloat := unsafe.Offsetof(example.FloatValue)
  38.    sizeBoolNext := unsafe.Sizeof(exampleNext.BoolValue)
  39.    offsetBoolNext := unsafe.Offsetof(exampleNext.BoolValue)
  41.    fmt.Printf("example Size: %d\n", unsafe.Sizeof(example))
  43.    fmt.Printf("Alignment Boundary: %d\n", alignmentBoundary)
  45.    fmt.Printf("BoolValue = Size: %d Offset: %d Addr: %v\n",
  46.       sizeBool, offsetBool, &example.BoolValue)
  48.    fmt.Printf("IntValue = Size: %d Offset: %d Addr: %v\n",
  49.       sizeInt, offsetInt, &example.IntValue)
  51.    fmt.Printf("FloatValue = Size: %d Offset: %d Addr: %v\n",
  52.       sizeFloat, offsetFloat, &example.FloatValue)
  54.    fmt.Printf("Next = Size: %d Offset: %d Addr: %v\n",
  55.       sizeBoolNext, offsetBoolNext, &exampleNext.BoolValue)
  57. }

输出：

example Size: 8 Alignment Boundary: 8 BoolValue = Size: 1 Offset: 0 Addr: 0xc00004c080 IntValue = Size: 2 Offset: 2 Addr: 0xc00004c082 FloatValue = Size: 4 Offset: 4 Addr: 0xc00004c084 Next = Size: 1 Offset: 0 Addr: 0xc00004c088

类型结构的对齐边界是预期的8个字节。

大小值显示将读取和写入该字段的内存量。正如所料，大小与类型信息一致。

偏移值显示进入内存占用的字节数，我们将找到该字段的开头。

地址是可以找到内存占用内每个字段的开头的地方。

我们可以看到Go在BoolValue和IntValue字段之间填充1个字节。偏移值和两个地址之间的差异是2个字节。您还可以看到下一个内存分配是从结构中的最后一个字段开始4个字节。

指针的使用

声明一个指针

使用以下语法声明类型为T的指针 

  1. var p *int

指针的零值是nil。这意味着任何未初始化的指针都将具有该值nil。让我们看一个完整的例子 

  1. package main
  2. import "fmt"
  4. func main() {
  5.     var p *int
  6.     &p=1
  7. }

注意：当指针没有指向的时候，不能对(*point)进行操作包括读取，否则会报空指针异常。

示例：

  1. package main
  3. func main() {
  4.    var p *int
  6.    *p = 1 //panic: runtime error: invalid memory address or nil pointer dereference
  8. }

解决方法即给该指针分配一个指向,即初始化一个内存，并把该内存地址赋予指针变量

示例：

  1. import "fmt"
  3. func main() {
  4.    var p *int
  5.    var m int
  6.    p = &m
  7.    *p = 1
  8.    fmt.Println("m=", m)
  9.    fmt.Println("p=", p)
  10. }

或还可以使用内置new()函数创建指针。该new()函数将类型作为参数，分配足够的内存以容纳该类型的值，并返回指向它的指针。

  1. import "fmt"
  3. func main() {
  4.    var p *int
  6.    p = new(int)
  7.    *p = 1
  8.    fmt.Println("p=", *p)
  9. }

初始化指针

您可以使用另一个变量的内存地址初始化指针。可以使用&运算符检索变量的地址

  1. var x = 100
  2. var p *int = &x

注意我们如何使用&带变量的运算符x来获取其地址，然后将地址分配给指针p。

就像Golang中的任何其他变量一样，指针变量的类型也由编译器推断。所以你可以省略p上面例子中指针的类型声明，并像这样写 

  1. var p = &a

取消引用指针

您可以*在指针上使用运算符来访问存储在指针所指向的变量中的值。这被称为解除引用或间接

  1. package main
  2. import "fmt"
  4. func main() {
  5.     var a = 100
  6.     var p = &a
  8.     fmt.Println("a = ", a)
  9.     fmt.Println("p = ", p)
  10.     fmt.Println("*p = ", *p)
  11. }

输出：

  1. a =  100
  2. p =  0xc00004c080
  3. *p =  100

您不仅可以使用*运算符访问指向变量的值，还可以更改它。以下示例a通过指针设置存储在变量中的值p

  1. package main
  2. import "fmt"
  4. func main() {
  5.     var a = 1000
  6.     var p = &a
  8.     fmt.Println("a (before) = ", a)
  10.     // Changing the value stored in the pointed variable through the pointer
  11.     *p = 2000
  13.     fmt.Println("a (after) = ", a)
  14. }

输出：

  1. a (before) =  1000
  2. a (after) =  2000

指针指向指针

指针可以指向任何类型的变量。它也可以指向另一个指针。以下示例显示如何创建指向另一个指针的指针 

  1. package main
  2. import "fmt"
  4. func main() {
  5.     var a = 7.98
  6.     var p = &a
  7.     var pp = &p
  9.     fmt.Println("a = ", a)
  10.     fmt.Println("address of a = ", &a)
  12.     fmt.Println("p = ", p)
  13.     fmt.Println("address of p = ", &p)
  15.     fmt.Println("pp = ", pp)
  17.     // Dereferencing a pointer to pointer
  18.     fmt.Println("*pp = ", *pp)
  19.     fmt.Println("**pp = ", **pp)
  20. }

Go中没有指针算术

如果您使用过C / C ++，那么您必须意识到这些语言支持指针算法。例如，您可以递增/递减指针以移动到下一个/上一个内存地址。您可以向/从指针添加或减去整数值。您也可以使用关系运算符比较两个三分球==，<，>等。

但Go不支持对指针进行此类算术运算。任何此类操作都将导致编译时错误 

  1. package main
  3. func main() {
  4.     var x = 67
  5.     var p = &x
  7.     var p1 = p + 1 // Compiler Error: invalid operation
  8. }

但是，您可以使用==运算符比较相同类型的两个指针的相等性。

  1. package main
  2. import "fmt"
  4. func main() {
  5.     var a = 75
  6.     var p1 = &a
  7.     var p2 = &a
  9.     if p1 == p2 {
  10.         fmt.Println("Both pointers p1 and p2 point to the same variable.")
  11.     }
  12. }

Go中传递简单类型

  1. import "fmt"
  3. func main() {
  4.    p := 5
  5.    change(&p)
  6.    fmt.Println("p=", p)//p= 0
  7. }
  8. func change(p *int) {
  9.    *p = 0
  10. }

Go中所有的都是按值传递，对于复杂类型，传的是指针的拷贝

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var m map[string]int
  7.     m = map[string]int{"one": 1, "two": 2}
  8.     n := m
  9.     fmt.Printf("%p\n", &m) //0xc000074018
  10.     fmt.Printf("%p\n", &n) //0xc000074020
  11.     fmt.Println(m)         // map[two:2 one:1]
  12.     fmt.Println(n)         //map[one:1 two:2]
  13.     changeMap(m)
  14.     fmt.Printf("%p\n", &m) //0xc000074018
  15.     fmt.Printf("%p\n", &n) //0xc000074020
  16.     fmt.Println(m)         //map[one:1 two:2 three:3]
  17.     fmt.Println(n)         //map[one:1 two:2 three:3]
  18. }
  19. func changeMap(m map[string]int) {
  20.     m["three"] = 3
  21.     fmt.Printf("changeMap func %p\n", m) //changeMap func 0xc000060240
  22. }

直接传指针 也是传指针的拷贝

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var m map[string]int
  7.     m = map[string]int{"one": 1, "two": 2}
  8.     n := m
  9.     fmt.Printf("%p\n", &m) //0xc000074018
  10.     fmt.Printf("%p\n", &n) //0xc000074020
  11.     fmt.Println(m)         // map[two:2 one:1]
  12.     fmt.Println(n)         //map[one:1 two:2]
  13.     changeMap(&m)
  14.     fmt.Printf("%p\n", &m) //0xc000074018
  15.     fmt.Printf("%p\n", &n) //0xc000074020
  16.     fmt.Println(m)         //map[one:1 two:2 three:3]
  17.     fmt.Println(n)         //map[two:2 three:3 one:1]
  18. }
  19. func changeMap(m *map[string]int) {
  20.     //m["three"] = 3 //这种方式会报错 invalid operation: m["three"] (type *map[string]int does not support indexing)
  21.     (*m)["three"] = 3                    //正确
  22.     fmt.Printf("changeMap func %p\n", m) //changeMap func 0x0
  23. }

总结：

  • Go 不能进行指针运算。

  • 指针传递是很廉价的，只占用 4 个或 8 个字节。当程序在工作中需要占用大量的内存，或很多变量，或者两者都有，使用指针会减少内存占用和提高效率。

  • 指针也是一种类型，不同于一般类型，指针的值是地址，这个地址指向其他的内存，通过指针可以读取其所指向的地址所存储的值。

  • 函数方法的接受者，也可以是指针变量。简单类型和复杂类型在传递的时候不同，复杂类型传值或传指针都是指针拷贝。
  • 只声明未赋值的变量，golang都会自动为其初始化为零值，基础数据类型的零值比较简单，引用类型和指针的零值都为nil，nil类型不能直接赋值，因此需要通过new开辟一个内存，或指向一个变量。

参考资料

http：//golang.org/doc/faq#Pointers

https://www.callicoder.com/golang-pointers/

https://www.ardanlabs.com/blog/2013/07/understanding-pointers-and-memory.html

https://www.ardanlabs.com/blog/2013/07/understanding-type-in-go.html

links