指针是一个代表着某个内存地址的值, 这个内存地址往往是在内存中存储的另一个变量的值的起始位置.

go语言对指针的支持介于java语言和 c/c++ 语言之间, 它既没有像java那样取消了代码对指针的直接操作的能力, 也避免了 c/c++ 中由于对指针的滥用而造成的安全和可靠性问题.

指针地址和变量空间

go语言保留了指针, 但是与c语言指针有所不同. 主要体现在:

&*->.

先来看一段代码:

package main

import "fmt"

func main(){ 
	var x int = 99
	var p *int = &x

	fmt.println(p)
}

var x int = 99x0xc00000a0c8x
var p *int = &xppx

所以, 指针就是地址, 指针变量就是存储地址的变量.

x
package main

import "fmt"

func main() {
	var x int = 99
	var p *int = &x

	fmt.println(p)

	x = 100

	fmt.println("x: ", x)
	fmt.println("*p: ", *p)
	
	*p = 999

	fmt.println("x: ", x)
	fmt.println("*p: ", *p)
}

x*p
*p解引用间接引用
*p = 999xx
x*p

栈帧的内存布局

32位

其中, 数据区保存的是初始化后的数据.

make()new()

接下来, 我们来了解一个新的概念: 栈帧.

stack

当函数调用时, 产生栈帧; 函数调用结束, 释放栈帧.

那么栈帧用来存放什么?

  • 局部变量
  • 形参
  • 内存字段描述值

其中, 形参与局部变量存储地位等同

main()
var x int = 99
var p *int = &x

如下图所示:

我们增加一个函数, 再来研究一下.

package main

import "fmt"

func test(m int){
	var y int = 66
	y += m
}

func main() {
	var x int = 99
	var p *int = &x

	fmt.println(p)

	x = 100

	fmt.println("x: ", x)
	fmt.println("*p: ", *p)

	test(11)

	*p = 999

	fmt.println("x: ", x)
	fmt.println("*p: ", *p)
}

test(11)main()
test()

空指针与野指针

空指针: 未被初始化的指针.

var p *int

*p

野指针: 被一片无效的地址空间初始化.

var p *int = 0xc00000a0c8

指针变量的内存存储

new(t)ttt*t
new()p := new(int)*p0
package main

import "fmt"

func main(){
	p := new(int)
	fmt.println(p)
	fmt.println(*p)
}

p
new()
*p
package main

import "fmt"

func main(){
	p := new(int)
	
	*p = 1000
	
	fmt.println(p)
	fmt.println(*p)
}

*p = 1000*pfmt.println(*p)*p

大家先思考一下, 然后先来看一个简单的例子:

var x int = 10
var y int = 20
x = y

var y int = 20yx = yy

结论: 不一样

var y int = 20yx = yy
x = yy

等号左边的变量代表变量所指向的内存空间, 相当于写操作.

等号右边的变量代表变量内存空间存储的数据值, 相当于读操作.

在了解了这个之后, 我们再来看一下之前的代码.

p := new(int)

*p = 1000

fmt.println(*p)

*p = 1000*p
fmt.println(*p)*p

所以这两者是不一样的.

如果我们不在main()创建会怎样?

func foo() {
	p := new(int)

	*p = 1000
}

foo()
p
ppnew()堆pp

对于堆区, 我们通常认为它是无限的. 但是无限的前提是必须申请完使用, 使用完后立即释放.

函数的传参

明白了上面的内容, 我们再去了解指针作为函数参数就会容易很多.

传地址(引用): 将地址值作为函数参数传递.

传值(数据): 将实参的值拷贝一份给形参.

无论是传地址还是传值, 都是实参将自己的值拷贝一份给形参.只不过这个值有可能是地址, 有可能是数据.

所以, 函数传参永远都是值传递.

了解了概念之后, 我们来看一个经典的例子:

package main

import "fmt"

func swap(x, y int){
	x, y = y, x
	fmt.println("swap  x: ", x, "y: ", y)
}

func main(){
	x, y := 10, 20
	swap(x, y)
	fmt.println("main  x: ", x, "y: ", y)
}

结果:

swap  x:  20 y:  10
main  x:  10 y:  20

我们先来简单分析一下为什么不一样.

main()xy
swap()xy
x, y = y, xswap()xymain()xy
swap()xy
fmt.println("main  x: ", x, "y: ", y)

接下来我们看一下参数为地址值时的情况.

传地址的核心思想是: 在自己的栈帧空间中修改其它栈帧空间中的值.

而传值的思想是: 在自己的栈帧空间中修改自己栈帧空间中的值.

注意理解其中的差别.

继续看以下这段代码:

package main

import "fmt"

func swap2(a, b *int){
	*a, *b = *b, *a
}

func main(){
	x, y := 10, 20
	swap(x, y)
	fmt.println("main  x: ", x, "y: ", y)
}

结果:

main  x:  20 y:  10

函数传参永远都是值传递
xy

我们来分析一下这个过程.

main()xy
swap2()ab
abxy
*a, *b = *b, *a*ax*bymain()x
swap2()main()
swap2()main()