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

本教程操作环境：windows10系统、GO 1.11.2、thinkpad t480电脑。

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

指针地址和变量空间

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

推荐学习：Golang教程

栈帧的内存布局

32位

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

make()new()

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

stack

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

那么栈帧用来存放什么?

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

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

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

如下图所示:

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

package mainimport "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 mainimport "fmt"func main(){
	p := new(int)
	fmt.Println(p)
	fmt.Println(*p)}
p
new()
*p
package mainimport "fmt"func main(){
	p := new(int)
	
	*p = 1000
	
	fmt.Println(p)
	fmt.Println(*p)}
*p = 1000*pfmt.Println(*p)*p

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

var x int = 10var y int = 20x = y
var y int = 20yx = yy

结论: 不一样

var y int = 20yx = yy
x = yy

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

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

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

p := new(int)*p = 1000fmt.Println(*p)
*p = 1000*p
fmt.Println(*p)*p

所以这两者是不一样的.

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

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

	*p = 1000}
foo()
p
ppnew()堆pp

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

函数的传参

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

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

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

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

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

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

package mainimport "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:  10main  x:  10 y:  20

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

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

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

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

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

注意理解其中的差别.

继续看以下这段代码:

package mainimport "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()