什么是指针？
指针是一个变量，用于存储另一个变量的内存地址。
在上面的例子中，变量b的值是156，存储在内存地址0x1040a124。 变量a包含b的地址。 可以说现在a指向b。
声明指针
指向类型 T 的指针用 *T 表示
让我们写一些代码。
package main import (
"fmt"
) func main() {
b := 255
var a *int = &b
fmt.Printf("Type of a is %T\n", a)
fmt.Println("address of b is", a)
}
＆运算符用于获取变量的地址。 在上面的程序中，我们将b的地址赋给一个类型为* int的类型。 据说现在a指向b。 当我们在a中打印该值时，b的地址将被打印。 这个程序输出
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_01.go"
Type of a is *int
address of b is 0xc042054080
你可能会得到一个不同的b地址，因为b的位置可以在内存中的任何地方。执行两次得到的结果
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_01.go"
Type of a is *int
address of b is 0xc042054080 [Done] exited with code=0 in 11.167 seconds [Running] go run "d:\GoProject\src\golang-study-line\basic-02\tempCodeRunnerFile.go"
Type of a is *int
address of b is 0xc04200e098 [Done] exited with code=0 in 0.954 seconds
空指针
指针的零值为 nil。
package main import (
"fmt"
) func main() {
a := 25
var b *int
if b == nil {
fmt.Println("b is", b)
b = &a
fmt.Println("b after initialization is", b)
}
}
b在上面的程序中最初是 nil，然后它被分配到a的地址。 这个程序输出（同样是执行两次）：
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_02.go"
b is <nil>
b after initialization is 0xc042054080 [Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_02.go"
b is <nil>
b after initialization is 0xc042054080
如何引用一个指针
如何引用指针意味着访问指针指向的变量的值。 * a是尊重a的语法。
让我们看看这是如何在程序中起作用的。
package main import (
"fmt"
) func main() {
b := 255
a := &b
fmt.Println("address of b is", a)
fmt.Println("value of b is", *a)
}
在上述程序的第10行中，我们引用并打印它的值。 如预期的那样，它打印出b的值。 该程序的输出是
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_03.go"
address of b is 0xc042054080
value of b is 255
让我们写一个更多的程序，我们使用指针改变b中的值。
package main import (
"fmt"
) func main() {
b := 255
a := &b
fmt.Println("address of b is", a)
fmt.Println("value of b is", *a)
*a++
fmt.Println("new value of b is", b)
}
在上面的程序中，我们将a指向的值增加1，这将b的值从a改变为b。 因此b的值变成256.程序的输出是
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_04.go"
address of b is 0xc04200e098
value of b is 255
new value of b is 256
将指针传递给一个函数
package main import (
"fmt"
) func change(val *int) {
*val = 55
} func main() {
a := 58
fmt.Println("value of a before function call is",a)
b := &a
change(b)
fmt.Println("value of a after function call is", a)
}
在上面的程序中，在第4行号。 我们将指针变量b传递给函数改变。 内部转换函数中，使用第8行中的解除引用来更改a的值。该程序输出，
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_05.go"
value of a before function call is 58
value of a after function call is 55
不要将指向数组的指针作为参数传递给函数。 改用切片。
让我们假设我们想对函数内的数组进行一些修改，并且调用者应该可以看到函数内对该数组所做的更改。 这样做的一种方式是将指向数组的指针作为函数的参数。
package main import (
"fmt"
) func modify(arr *[3]int) {
(*arr)[0] = 90
} func main() {
a := [3]int{89, 90, 91}
modify(&a)
fmt.Println(a)
}
在上面的程序中的第3行号，我们将数组a的地址传递给修改函数。 在修改函数的第8行中，我们取消引用arr并将90分配给数组的第一个元素。 这个程序输出
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\tempCodeRunnerFile.go"
[90 90 91]
a [x]是（* a）[x]的简写。 所以上述程序中的（* arr）[0]可以用arr [0]代替。
让我们用这种简写语法重写上述程序。
package main import (
"fmt"
) func modify(arr *[3]int) {
arr[0] = 90
} func main() {
a := [3]int{89, 90, 91}
modify(&a)
fmt.Println(a)
}
这个程序也输出
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_07.go"
[90 90 91]
虽然这种将指向数组的指针作为参数传递给函数并对其进行修改的方式很有效，但这并不是在Go中实现此功能的惯用方式。 我们可以使用切片。
让我们用切片重写相同的程序。
package main import (
"fmt"
) func modify(sls []int) {
sls[0] = 90
} func main() {
a := [3]int{89, 90, 91}
modify(a[:])
fmt.Println(a)
}
在上述程序的第13行中，我们将一个切片传递给修改函数。 切片的第一个元素在修改函数中更改为90。
这个程序输出
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_08.go"
[90 90 91]
所以避免传递指向数组的指针，使用切片代替它。 这段代码更干净并且是惯用的Go
Go不支持指针算术
Go不支持C语言等其他语言中的指针运算。
package main
func main() {
b := [...]int{109, 110, 111}
p := &b
p++
}
上面的程序会抛出编译错误
[Running] go run "d:\GoProject\src\golang-study-line\basic-02\basic_pointer_09.go"
# command-line-arguments
basic-02\basic_pointer_09.go:6:6: invalid operation: p++ (non-numeric type *[3]int)
参考：