Go指针理解
Go 有指针，但是没有指针运算。你不能用指针变量遍历字符串的各个字节。在 Go 中调用函数的时候，得记得变量是值传递的。
通过类型作为前缀来定义一个指针’ * ’：var p * int。现在 p 是一个指向整数值的指针。所有新定义的变量都被赋值为其类型的零值，而指针也一样。一个新定义的或者没有任何指向的指针，有值 nil。在其他语言中，这经常被叫做空（NULL）指针，在 Go 中就是 nil 。让指针指向某些内容，可以使用取址操作符 （ & ），像这样：
package main
import "fmt"
func main() {
var p *int
fmt.Printf("%vn",p) //← 打印 nil
var i int //← 定义一个整形变量 i
p = &i //← 使得 p 指向 i， 获取 i 的地址
fmt.Printf("%vn",p) //打印内存地址
*p = 6
fmt.Printf("%vn",*p) //打印6
fmt.Printf("%vn",i) //打印6
}
前面已经说了，没有指针运算，所以如果这样写： p++ ，它表示 (p)++ ：首先获取指针指向的值，然后对这个值加一。这里注意与C语言的区别。
对于Go语言，严格意义上来讲，只有一种传递，也就是按值传递(by value)。当一个变量当作参数传递的时候，会创建一个变量的副本，然后传递给函数或者方法，你可以看到这个副本的地址和变量的地址是不一样的。
当变量当做指针被传递的时候，一个新的指针被创建，它指向变量指向的同样的内存地址，所以你可以将这个指针看成原始变量指针的副本。当这样理解的时候，我们就可以理解成Go总是创建一个副本按值转递，只不过这个副本有时候是变量的副本，有时候是变量指针的副本。
指针与普通变量区别
刚学习golang的人可能不是很明白普通变量和指针的区别，看到有人说其实普通变量是程序创造出来的，比如说 C 中的 a int ，那么在编译时 就会有 [a 地址 int] 这样来标识内存。
普通变量a其实是语言本身创造了，是为了更方便的表示内存。我们对a进行访问其实就是直接对内存进行访问。至于a表示的内存的地址是多少，程序员一般不用关心。编译器会自动分配地址，也就是常说的为a分配一个地址。如果想知道a的地址也可以通过&a得知。
打个比方来理解：普通变量就像是房间(内存)外面的门牌号(总经理室)，指针就是这个房间的地址(9#905)
变量是运行时系统给这个内存起的别名，内存地址是唯一的，程序中当我想拿到这个内存的值的时候，因为知道它的别名，所以直接用别名访问就可以得到值，又或者我能知道它唯一的地址我也能得到它的值，其实是两种不同的内存访问方式，但是变量是会变的，地址是不会变的。比如在go中
：
package main
func main(){
a := 10 //此时有一块内存存放了10，它的地址由系统自动分配，别名是a
a = 20 //内存存放的10变成了20
var p *int
p = &a //或者直接写 p := &a
//上面的p是一个指针，通过 *p 的方式同样可以访问 变量a指向 的内存
/*当你动态申请内存的时候，指针的存在意义之一就被体现出来了*/
ptr := new(int)
//申请了一块内存空间，没有办法指定别名，new()返回内存地址，用指针接收
//此时并没有变量能直接指向这块内存，所以只能通过内存地址来访问
}
看到有个解释还可以，是说指针和普通变量区别的：
1+2这个表达式永远得值3；
a+b这个表达式只依赖于a,b的值—–按名字访问称为直接访问；
*p + *q 这个表达式的值随着p，q指向的变量不同而不同—-按指针访问称为间接访问；
指针的使用
方法中的指针；方法即为有接受者的函数，接受者可以是类型的实例变量或者是类型的实例指针变量。但两种效果不同。
1. 类型的实例变量
func main(){
person := Person{"TigerwolfC", 25}
fmt.Printf("person<%s:%d>n", person.name, person.age)
person.sayHi()
person.ModifyAge(28)
person.sayHi()
}
type Person struct {
name string
age int
}
func (p Person) sayHi() {
fmt.Printf("SayHi -- This is %s, my age is %dn",p.name, p.age)
}
func (p Person) ModifyAge(age int) {
fmt.Println("ModifyAge")
p.age = age
}
// 输出结果
person<TigerwolfC:25>
SayHi -- This is TigerwolfC, my age is 25
ModifyAge
SayHi -- This is TigerwolfC, my age is 25
尽管 ModifyAge 方法修改了其age字段，可是方法里的p是person变量的一个副本，修改的只是副本的值。下一次调用sayHi方法的时候，还是person的副本，因此修改方法并不会生效。即实例变量的方式并不会改变接受者本身的值。
2. 类型的实例指针变量
package main
import "fmt"
func main(){
person := Person{"TigerwolfC", 25}
fmt.Printf("person<%s:%d>n", person.name, person.age)
person.sayHi()
person.ModifyAge(28)
person.sayHi()
}
type Person struct {
name string
age int
}
func (p *Person) sayHi() {
fmt.Printf("SayHi -- This is %s, my age is %dn",p.name, p.age)
}
func (p *Person) ModifyAge(age int) {
fmt.Println("ModifyAge")
p.age = age
}
// 输出结果
person<TigerwolfC:25>
SayHi -- This is TigerwolfC, my age is 25
ModifyAge
SayHi -- This is TigerwolfC, my age is 28
Go会根据Person的示例类型，转换成指针类型再拷贝，即 person.ModifyAge会变成 (&person).ModifyAge。
指针类型的接受者，如果实例对象是值，那么go会转换成指针，然后再拷贝，如果本身就是指针对象，那么就直接拷贝指针实例。因为指针都指向一处值，就能修改对象了。
3. 如何选择 P 和 *P
在定义函数和方法的时候，需要对函数的参数和返回值定义成 P 和 *P 深思熟虑，有些情况下可能还会有些困惑。
那么什么时候才应该把参数定义成类型 P ,什么情况下定义成类型 *P 呢。
一般的判断标准是看副本创建的成本和需求。
- 不想变量被修改。 如果你不想变量被函数和方法所修改，那么选择类型P。相反，如果想修改原始的变量，则选择*P
。- 如果变量是一个大的struct或者数组，则副本的创建相对会影响性能，这个时候考虑使用*P，只创建新的指针，这个区别是巨大的
。- (不针对函数参数，只针对本地变量／本地变量)对于函数作用域内的参数，如果定义成P，Go编译器尽量将对象分配到栈上，而*P很可能会分配到对象上，这对垃圾回收会有影响。
4. 零值与nil(空指针)
变量声明而没有赋值，默认为零值，不同类型零值不同，例如字符串零值为空字符串；
指针声明而没有赋值，默认为nil，即该指针没有任何指向。当指针没有指向的时候，不能对(*point)进行操作包括读取，否则会报空指针异常。
func main(){
// 声明一个指针变量 aPot 其类型也是 string
var aPot *string
fmt.Printf("aPot: %p %#vn", &aPot, aPot) // 输出 aPot: 0xc42000c030 (*string)(nil)
*aPot = "This is a Pointer" // 报错： panic: runtime error: invalid memory address or nil pointer dereference
}
解决方法即给该指针分配一个指向,即初始化一个内存，并把该内存地址赋予指针变量，例如：// 声明一个指针变量 aPot 其类型也是 string。
var aPot *string
fmt.Printf("aPot: %p %#vn", &aPot, aPot) // 输出 aPot: 0xc42000c030 (*string)(nil)
aPot = &aVar
*aPot = "This is a Pointer"
fmt.Printf("aVar: %p %#v n", &aVar, aVar) // 输出 aVar: 0xc42000e240 "This is a Pointer"
fmt.Printf("aPot: %p %#v %#v n", &aPot, aPot, *aPot) // 输出 aPot: 0xc42000c030 (*string)(0xc42000e240) "This is a Pointer"
或者通过new开辟一个内存，并返回这个内存的地址。
var aNewPot *int
aNewPot = new(int)
*aNewPot = 666
fmt.Printf("aNewPot: %p %#v %#v n", &aNewPot, aNewPot, *aNewPot) // 输出 aNewPot: 0xc42007a028 (*int)(0xc42006e1f0) 666
总结
- Golang提供了指针用于操作数据内存，并通过引用来修改变量。
只声明未赋值的变量， - golang都会自动为其初始化为零值，基础数据类型的零值比较简单，引用类型和指针的零值都为nil，nil类型不能直接赋值，因此需要通过new开辟一个内存，或者通过make初始化数据类型，或者两者配合，然后才能赋值。
- 指针也是一种类型，不同于一般类型，指针的值是地址，这个地址指向其他的内存，通过指针可以读取其所指向的地址所存储的值。
- 函数方法的接受者，也可以是指针变量。无论普通接受者还是指针接受者都会被拷贝传入方法中，不同在于拷贝的指针，其指向的地方都一样，只是其自身的地址不一样。
原文地址：
https://blog.csdn.net/wade3015/article/details/85855141