共计 7211 个字符，预计需要花费 19 分钟才能阅读完成。
定义
了解指针之前，先讲一下什么是变量。
每当我们编写任何程序时，我们都需要在内存中存储一些数据 / 信息。数据存储在特定地址的存储器中。内存地址看起来像 0xAFFFF（这是内存地址的十六进制表示）。
现在，要访问数据，我们需要知道存储它的地址。我们可以跟踪存储与程序相关的数据的所有内存地址。但想象一下，记住所有内存地址并使用它们访问数据会有非常困难。这就是为什么引入变量。
变量是一种占位符，用于引用计算机的内存地址，可理解为内存地址的标签。
什么是指针
指针是存储另一个变量的内存地址的变量。所以指针也是一种变量，只不过它是一种特殊变量，它的值存放的是另一个变量的内存地址。
在上面的例子中，指针 p 包含值 0x0001，该值是变量的地址 a。
Go 类型占用内存情况
unsafe 包可以获取变量的内存使用情况
Go 语言提供以下基本数字类型：
无符号整数 uint8，uint16，uint32，uint64
符号整数 int8，int16，int32，int64
实数 float32，float64 Predeclared
整数(依赖系统类型，跟系统有关)uint，int，uintptr（指针）
32 位系统
uint=uint32int=int32uintptr 为 32 位的指针
64 位系统
uint=uint64int=int64uintptr 为 64 位的指针
示例：
package main
import (
“fmt”
“unsafe”
)
func main() {
var uint8Value uint8
var uint16Value uint16
var uint32Value uint32
var uint64Value uint64
var int8Value int8
var int16Value int16
var int32Value int32
var int64Value int64
var float32Value float32
var float64Value float64
fmt.Println(“uint8Value = Size:”, unsafe.Sizeof(uint8Value)) //uint8Value = Size: 1
fmt.Println(“uint16Value = Size:”, unsafe.Sizeof(uint16Value)) //uint16Value = Size: 2
fmt.Println(“uint32Value = Size:”, unsafe.Sizeof(uint32Value)) //uint32Value = Size: 4
fmt.Println(“uint64Value = Size:”, unsafe.Sizeof(uint64Value))// uint64Value = Size: 8
fmt.Println(“int8Value = Size:”, unsafe.Sizeof(int8Value)) //int8Value = Size: 1
fmt.Println(“int16Value = Size:”, unsafe.Sizeof(int16Value))//int16Value = Size: 2
fmt.Println(“int32Value = Size:”, unsafe.Sizeof(int32Value))//int32Value = Size: 4
fmt.Println(“int64Value = Size:”, unsafe.Sizeof(int64Value)) //int64Value = Size: 8
fmt.Println(“float32Value = Size:”, unsafe.Sizeof(float32Value)) //float32Value = Size: 4
fmt.Println(“float64Value = Size:”, unsafe.Sizeof(float64Value))//float64Value = Size: 8
}
上面的是基本类型，接下来了解下复杂类型，以结构体类型为例
type Example struct {
BoolValue bool
IntValue int16
FloatValue float32
}
该结构代表复杂类型。它代表 7 个字节，带有三个不同的数字表示。bool 是一个字节，int16 是 2 个字节，float32 增加 4 个字节。但是，在此结构的内存中实际分配了 8 个字节。
所有内存都分配在对齐边界上，以最大限度地减少内存碎片整理。要确定对齐边界 Go 用于您的体系结构，您可以运行 unsafe.Alignof 函数。Go 为 64bit Darwin 平台的对齐边界是 8 个字节。因此，当 Go 确定结构的内存分配时，它将填充字节以确保最终内存占用量是 8 的倍数。编译器将确定添加填充的位置。
什么是内存对齐呢？
内存对齐，也叫边界对齐（boundary alignment)，是处理器为了提高处理性能而对存取数据的起始地址所提出的一种要求。编译器为了使我们编写的 C 程序更有效，就必须最大限度地满足处理器对边界对齐的要求。
从处理器的角度来看，需要尽可能减少对内存的访问次数以实现对数据结构进行更加高效的操作。为什么呢？因为尽管处理器包含了缓存，但它在处理数据时还得读取缓存中的数据，读取缓存的次数当然是越少越好！如上图所示，在采用边界对齐的情况下，当处理器需要访问 a_变量和 b_变量时都只需进行一次存取（图中花括号表示一次存取操作）。若不采用边界对齐，a_变量只要一次处理器操作，而 b_变量却至少要进行两次操作。对于 b_, 处理器还得调用更多指令将其合成一个完整的 4 字节，这样无疑大大降低了程序效率。
以下程序显示 Go 插入到 Example 类型 struct 的内存占用中的填充：
package main
import (
“fmt”
“unsafe”
)
type Example struct {
BoolValue bool
IntValue int16
FloatValue float32
}
func main() {
example := &Example{
BoolValue: true,
IntValue: 10,
FloatValue: 3.141592,
}
exampleNext := &Example{
BoolValue: true,
IntValue: 10,
FloatValue: 3.141592,
}
alignmentBoundary := unsafe.Alignof(example)
sizeBool := unsafe.Sizeof(example.BoolValue)
offsetBool := unsafe.Offsetof(example.BoolValue)
sizeInt := unsafe.Sizeof(example.IntValue)
offsetInt := unsafe.Offsetof(example.IntValue)
sizeFloat := unsafe.Sizeof(example.FloatValue)
offsetFloat := unsafe.Offsetof(example.FloatValue)
sizeBoolNext := unsafe.Sizeof(exampleNext.BoolValue)
offsetBoolNext := unsafe.Offsetof(exampleNext.BoolValue)
fmt.Printf(“example Size: %d\n”, unsafe.Sizeof(example))
fmt.Printf(“Alignment Boundary: %d\n”, alignmentBoundary)
fmt.Printf(“BoolValue = Size: %d Offset: %d Addr: %v\n”,
sizeBool, offsetBool, &example.BoolValue)
fmt.Printf(“IntValue = Size: %d Offset: %d Addr: %v\n”,
sizeInt, offsetInt, &example.IntValue)
fmt.Printf(“FloatValue = Size: %d Offset: %d Addr: %v\n”,
sizeFloat, offsetFloat, &example.FloatValue)
fmt.Printf(“Next = Size: %d Offset: %d Addr: %v\n”,
sizeBoolNext, offsetBoolNext, &exampleNext.BoolValue)
}
输出：
example Size: 8Alignment Boundary: 8BoolValue = Size: 1 Offset: 0 Addr: 0xc00004c080IntValue = Size: 2 Offset: 2 Addr: 0xc00004c082FloatValue = Size: 4 Offset: 4 Addr: 0xc00004c084Next = Size: 1 Offset: 0 Addr: 0xc00004c088
类型结构的对齐边界是预期的 8 个字节。
大小值显示将读取和写入该字段的内存量。正如所料，大小与类型信息一致。
偏移值显示进入内存占用的字节数，我们将找到该字段的开头。
地址是可以找到内存占用内每个字段的开头的地方。
我们可以看到 Go 在 BoolValue 和 IntValue 字段之间填充 1 个字节。偏移值和两个地址之间的差异是 2 个字节。您还可以看到下一个内存分配是从结构中的最后一个字段开始 4 个字节。
指针的使用
声明一个指针
使用以下语法声明类型为 T 的指针
var p *int
指针的零值是 nil。这意味着任何未初始化的指针都将具有该值 nil。让我们看一个完整的例子
package main
import “fmt”
func main() {
var p *int
&p=1
}
注意：当指针没有指向的时候，不能对 (*point) 进行操作包括读取，否则会报空指针异常。
示例：
package main
func main() {
var p *int
*p = 1 //panic: runtime error: invalid memory address or nil pointer dereference
}
解决方法即给该指针分配一个指向, 即初始化一个内存，并把该内存地址赋予指针变量
示例：
import “fmt”
func main() {
var p *int
var m int
p = &m
*p = 1
fmt.Println(“m=”, m)
fmt.Println(“p=”, p)
}
或还可以使用内置 new()函数创建指针。该 new()函数将类型作为参数，分配足够的内存以容纳该类型的值，并返回指向它的指针。
import “fmt”
func main() {
var p *int
p = new(int)
*p = 1
fmt.Println(“p=”, *p)
}
初始化指针
您可以使用另一个变量的内存地址初始化指针。可以使用 & 运算符检索变量的地址
var x = 100
var p *int = &x
注意我们如何使用 & 带变量的运算符 x 来获取其地址，然后将地址分配给指针 p。
就像 Golang 中的任何其他变量一样，指针变量的类型也由编译器推断。所以你可以省略 p 上面例子中指针的类型声明，并像这样写
var p = &a
取消引用指针
您可以 * 在指针上使用运算符来访问存储在指针所指向的变量中的值。这被称为解除引用或间接
package main
import “fmt”
func main() {
var a = 100
var p = &a
fmt.Println(“a = “, a)
fmt.Println(“p = “, p)
fmt.Println(“*p = “, *p)
}
输出：
a = 100
p = 0xc00004c080
*p = 100
您不仅可以使用 * 运算符访问指向变量的值，还可以更改它。以下示例 a 通过指针设置存储在变量中的值 p
package main
import “fmt”
func main() {
var a = 1000
var p = &a
fmt.Println(“a (before) = “, a)
// Changing the value stored in the pointed variable through the pointer
*p = 2000
fmt.Println(“a (after) = “, a)
}
输出：
a (before) = 1000
a (after) = 2000
指针指向指针
指针可以指向任何类型的变量。它也可以指向另一个指针。以下示例显示如何创建指向另一个指针的指针
package main
import “fmt”
func main() {
var a = 7.98
var p = &a
var pp = &p
fmt.Println(“a = “, a)
fmt.Println(“address of a = “, &a)
fmt.Println(“p = “, p)
fmt.Println(“address of p = “, &p)
fmt.Println(“pp = “, pp)
// Dereferencing a pointer to pointer
fmt.Println(“*pp = “, *pp)
fmt.Println(“**pp = “, **pp)
}
Go 中没有指针算术
如果您使用过 C / C ++，那么您必须意识到这些语言支持指针算法。例如，您可以递增 / 递减指针以移动到下一个 / 上一个内存地址。您可以向 / 从指针添加或减去整数值。您也可以使用关系运算符比较两个三分球 ==，<，> 等。
但 Go 不支持对指针进行此类算术运算。任何此类操作都将导致编译时错误
package main
func main() {
var x = 67
var p = &x
var p1 = p + 1 // Compiler Error: invalid operation
}
但是，您可以使用 == 运算符比较相同类型的两个指针的相等性。
package main
import “fmt”
func main() {
var a = 75
var p1 = &a
var p2 = &a
if p1 == p2 {
fmt.Println(“Both pointers p1 and p2 point to the same variable.”)
}
}
Go 中传递简单类型
import “fmt”
func main() {
p := 5
change(&p)
fmt.Println(“p=”, p)//p= 0
}
func change(p *int) {
*p = 0
}
Go 中所有的都是按值传递，对于复杂类型，传的是指针的拷贝
package main
import “fmt”
func main() {
var m map[string]int
m = map[string]int{“one”: 1, “two”: 2}
n := m
fmt.Printf(“%p\n”, &m) //0xc000074018
fmt.Printf(“%p\n”, &n) //0xc000074020
fmt.Println(m) // map[two:2 one:1]
fmt.Println(n) //map[one:1 two:2]
changeMap(m)
fmt.Printf(“%p\n”, &m) //0xc000074018
fmt.Printf(“%p\n”, &n) //0xc000074020
fmt.Println(m) //map[one:1 two:2 three:3]
fmt.Println(n) //map[one:1 two:2 three:3]
}
func changeMap(m map[string]int) {
m[“three”] = 3
fmt.Printf(“changeMap func %p\n”, m) //changeMap func 0xc000060240
}
直接传指针 也是传指针的拷贝
package main
import “fmt”
func main() {
var m map[string]int
m = map[string]int{“one”: 1, “two”: 2}
n := m
fmt.Printf(“%p\n”, &m) //0xc000074018
fmt.Printf(“%p\n”, &n) //0xc000074020
fmt.Println(m) // map[two:2 one:1]
fmt.Println(n) //map[one:1 two:2]
changeMap(&m)
fmt.Printf(“%p\n”, &m) //0xc000074018
fmt.Printf(“%p\n”, &n) //0xc000074020
fmt.Println(m) //map[one:1 two:2 three:3]
fmt.Println(n) //map[two:2 three:3 one:1]
}
func changeMap(m *map[string]int) {
//m[“three”] = 3 // 这种方式会报错 invalid operation: m[“three”] (type *map[string]int does not support indexing)
(*m)[“three”] = 3 // 正确
fmt.Printf(“changeMap func %p\n”, m) //changeMap func 0x0
}
总结：
Go 不能进行指针运算。
指针传递是很廉价的，只占用 4 个或 8 个字节。当程序在工作中需要占用大量的内存，或很多变量，或者两者都有，使用指针会减少内存占用和提高效率。
指针也是一种类型，不同于一般类型，指针的值是地址，这个地址指向其他的内存，通过指针可以读取其所指向的地址所存储的值。
函数方法的接受者，也可以是指针变量。简单类型和复杂类型在传递的时候不同，复杂类型传值或传指针都是指针拷贝。
只声明未赋值的变量，golang 都会自动为其初始化为零值，基础数据类型的零值比较简单，引用类型和指针的零值都为 nil，nil 类型不能直接赋值，因此需要通过 new 开辟一个内存，或指向一个变量。
参考资料
http：//golang.org/doc/faq#Pointers
https://www.callicoder.com/go…
https://www.ardanlabs.com/blo…
https://www.ardanlabs.com/blo…
links
目录
