title

• 1. go中的指针
• 2. 函数中的指针
• 3. 方法中的指针

1. go中的指针

使用 *类型 声明指针…
使用*变量名获取指针的值…
使用 &p 获取指针的内存地址…

	fmt.Println("======== 指针复习 ========")
	// 声明指针a
	var a *int
	b := 1
	// 获取到b的内存地址.. 指向b
	a = &b
	fmt.Println(a, &b, " 获取到指针变量的值 ", *a)

2. 函数中的指针

go 函数中的指针默认是值传递，即传递类型参数，是对当前类型的拷贝。而不是传递引用。如果传递参数指针，则改变原来参数的值。

package main

import "fmt"

type Vertex struct {
	X, Y float64
}

func show1(v Vertex) {
	v.X = 9
	v.Y = 9
}

func show(v *Vertex) {

	v.X = 9
	v.Y = 9
}

func main() {

	v := Vertex{1, 2}

	show1(v)
	fmt.Println(v)

	show(&v)
	fmt.Println(v)
}

可以看到结果… 传递指针的改变了原来的值…

$ go run .
{1 2}
{9 9}

而对于go中函数，参数是什么类型，传递就是什么类型

func show(v *Vertex) {
	v.X = 9
	v.Y = 9
}

// 错误
v := Vertex{1, 2}
show(v)

// 正确
v := &Vertex{1, 2}
show(v)

3. 方法中的指针

go中的方法，有个方法接收者。这也是和函数的区别。某个结构体或者类型，可以给它们设置方法。

// 结构体的方法, (v *Vertex)为方法接收者
func (v *Vertex) changeOrg() {
	v.X, v.Y = 3.0, 3.0
	fmt.Println("in changeOrg ", *v)
}

// (v Vertex)为方法接收者
func (v Vertex) nothingChange() {
	v.X, v.Y = 3.0, 3.0
	fmt.Println("copy one ", v)
}

方法的指针可以重定向.这里说会比较晦涩。即接收者是指针，可以用值类型调用。接收者是值类型，也可以用指针调用。

	v := Vertex{99, 99}

	// 参数是指针, 方法能为值v
	// 由于 changeOrg 方法有一个指针接收者，为方便起见，Go 会将语句 v.changeOrg() 解释为 (&v).changeOrg()。
	v.changeOrg()
	// (&v).changeOrg()

或者

	v := Vertex{1, 1}
	// 值调用
	v.nothingChange()
	fmt.Println(v)

	p := &v
	// 方法支持指针调用
	p.nothingChange()
	// (*p).m1()
	fmt.Println(v)