一、指针的概念
1、什么是指针
指针是存储另一个变量的内存地址的变量。
变量是一种使用方便的占位符，用于引用计算机内存地址。
一个指针变量可以指向任何一个值的内存地址。
2、获取变量的地址
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
package main
import (
"fmt"
)
func main() {
var a int = 1
fmt.Println("变量a的内存地址是:", &a)
}
运行结果
变量a的内存地址是: 0xc000012090
3、声明指针
var ptr *type
type 为指针类型，ptr 为指针变量名，* 用于指定变量是作为一个指针。
package main
import (
"fmt"
)
func main() {
var a int = 1
fmt.Println("变量a的内存地址是:", &a)
var ptr *int
ptr = &a
fmt.Println("变量ptr的内存地址是:", &ptr)
fmt.Println("变量ptr的值为:", ptr)
}
运行结果
变量a的内存地址是: 0xc000012090
变量ptr的内存地址是: 0xc000006030
变量ptr的值为: 0xc000012090
4、空指针
当一个指针被定义后没有分配到任何变量时，它的值为 nil。
nil 指针也称为空指针。
nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。
package main
import (
"fmt"
)
func main() {
var ptr *int
fmt.Println("变量ptr的内存地址是:", &ptr)
fmt.Println("变量ptr的值为:", ptr)
fmt.Println(ptr == nil)
}
运行结果
变量ptr的内存地址是: 0xc000006028
变量ptr的值为:
true
二、指针的使用
1、获取指针的值
*ptr 访问指针变量指向的原变量的值
package main
import (
"fmt"
)
func main() {
var a int = 1
var ptr *int
ptr = &a
fmt.Println("a的内存地址是", ptr)
fmt.Println("a的值是", *ptr)
}
运行结果
a的内存地址是 0xc000012090
a的值是 1
取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。
变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：
- 对变量进行取地址操作使用
&操作符，可以获得这个变量的指针变量。 - 指针变量的值是指针地址。
- 对指针变量进行取值操作使用
*操作符，可以获得指针变量指向的原变量的值。
2、操作指针改变变量的值
package main
import (
"fmt"
)
func main() {
var a int = 1
var ptr *int
ptr = &a
fmt.Println("a的内存地址是", ptr)
fmt.Println("a的值是", *ptr)
*ptr = 2
fmt.Println("a的值为", a)
}
运行结果
a的内存地址是 0xc000012090
a的值是 1
a的值为 2
3、指针数组和数组指针
- 数组指针
首先是一个指针，存放的是一个数组的地址
*[len]type
package main
import "fmt"
func main() {
arr := [4]int{1, 2, 3, 5}
fmt.Println(arr)
var ptr *[4]int
ptr = &arr
fmt.Println(ptr)
fmt.Printf("%p\n", ptr) //数组arr的地址
fmt.Printf("%p\n", &ptr) //指针变量ptr的地址
(*ptr)[0] = 100 //通过指针操作数组
fmt.Println(arr)
ptr[0] = 200 //简化写法
fmt.Println(arr)
}
运行结果
[1 2 3 5]
&[1 2 3 5]
0xc0000103e0
0xc000006030
[100 2 3 5]
[200 2 3 5]
- 指针数组
首先是一个数组，存储的数据类型是指针
[len]*type
package main
import "fmt"
func main() {
a, b, c, d := 1, 2, 3, 4
var arr [4]int
var ptr [4]*int
arr = [4]int{a, b, c, d}
ptr = [4]*int{&a, &b, &c, &d}
fmt.Println(arr)
fmt.Println(ptr)
*ptr[0] = 100
fmt.Println(arr) // 数组中存储的是a的值1，所以改变a变量与arr无关
fmt.Println(a)
arr[0] = 200
fmt.Println(ptr)
fmt.Println(a) // 数组中存储的是a的值1，所以改变arr[0]与变量a无关
}
运行结果
[1 2 3 4]
[0xc000012090 0xc000012098 0xc0000120a0 0xc0000120a8]
[1 2 3 4]
100
[0xc000012090 0xc000012098 0xc0000120a0 0xc0000120a8]
100
4、函数指针和指针函数
- 函数指针
一个指针，指向了一个函数
go语言中，函数默认看做一个指针，没有*，引用类型的数据如map，slice，function都是如此。
package main
import "fmt"
func main() {
var a func()
a = fun
a()
}
func fun() {
fmt.Println("hello world")
}
运行结果
hello world
- 指针函数
一个函数，返回值是一个指针
package main
import "fmt"
func main() {
arr := fun1()
fmt.Printf("%T, %p, %v\n", arr, &arr, arr)
ptr := fun2()
fmt.Printf("%T, %p, %v\n", ptr, &ptr, ptr)
}
func fun1() [4]int {
arr := [4]int{1, 2, 3, 4}
return arr
}
func fun2() *[4]int {
arr := [4]int{1, 2, 3, 4}
return &arr
}
运行结果
[4]int, 0xc0000103e0, [1 2 3 4]
*[4]int, 0xc000006030, &[1 2 3 4]
5、指针传参
Go 语言允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可。
package main
import "fmt"
func main() {
arr := [4]int{1, 2, 3, 4}
fmt.Println("函数调用前arr:", arr)
fun1(arr)
fmt.Println("函数fun1调用后arr:", arr)
fun2(&arr)
fmt.Println("函数fun2调用后arr:", arr)
}
func fun1(arr [4]int) {
fmt.Println("fun1中数组的值：", arr)
arr[0] = 100
fmt.Println("fun1中数组的值：", arr)
}
func fun2(arr *[4]int) {
fmt.Println("fun2中数组的值：", arr)
arr[0] = 200
fmt.Println("fun2中数组的值：", arr)
}
运行结果
函数调用前arr: [1 2 3 4]
fun1中数组的值： [1 2 3 4]
fun1中数组的值： [100 2 3 4]
函数fun1调用后arr: [1 2 3 4]
fun2中数组的值： &[1 2 3 4]
fun2中数组的值： &[200 2 3 4]
函数fun2调用后arr: [200 2 3 4]
6、什么情况下使用指针
- 推荐在方法上使用指针
- 当结构体较大的时候使用指针会更高效，可以避免内存拷贝
- 如果要修改结构体内部的数据或状态必须使用指针
- 如果方法的receiver是map、slice 、channel等引用类型不要使用指针
- 小数据类型如 bool、int 等没必要使用指针传递
- 如果该函数会修改receiver或变量等，使用指针
三、make和new
package main
import (
"fmt"
)
func main() {
var a *int
b := 10
*a = b // 报错，a声明但是没有初始化，是nil，所以不能指向b。
// a = &b //不报错，这里是把b的内存地址赋值给a，在赋值的同时给a分配内存空间
fmt.Println(a)
}
运行结果
panic: runtime error: invalid memory address or nil pointer dereference
执行上面的代码会引发panic，为什么呢？
Go语言中对于引用类型的变量，在使用的时候不仅要声明它，还要为它分配内存空间，否则我们的值就没办法存储。
而对于值类型的变量不需要主动分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。
Go语言中new和make是内建的两个函数，主要用来分配内存。
new
ptr := new(type)
new() 函数可以创建一个对应类型的指针，创建过程会分配内存，被创建的指针指向默认值。
package main
import (
"fmt"
)
func main() {
a := new(int)
b := new(bool)
fmt.Printf("a的类型是%T\n", a)
fmt.Printf("b的类型是%T\n", b)
fmt.Println(*a)
fmt.Println(*b)
}
运行结果
a的类型是*int
b的类型是*bool
0
false
make
make也是用于内存分配的，区别于new，它只用于slice、map以及chan的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。
make(T, args)
new与make的区别
- 二者都是用来做内存分配的。
- make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身；
- new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。