golang指针和变量（golang函数参数传递）
golang指针和变量（golang函数参数传递）/main.go:12:10: cannot convert 1 (untyped int constant) to *int其实 golang 的指针也并非是完全不能进行加减乘除运算的，但是需要先用 unsafe.pointer 把指针先转为整数，但是这目前不是本章的重点，后面我会写一篇专门的文档。package main import "fmt" func main() { var a int = 1 testfunc(&a) fmt.Printf("a=%d\n" a) } func testfunc(a *int) { a = a 1 }报错信息package main import "fmt" func main() { var a int = 1 testfunc(&
这一章节我们来分析一下 golang 值，指针，引用的区别。在大学我们学习 C 语言对值和指针已经有足够了解了，但是引用这个概念是在更高级的语言中引入的，比如 java，引用和指针很像，但是它和指针有上面区别呢？为什么需要应用？。接下来我们通过一些示例一一了解他们。
可以理解为变量存储的内容，或者说变量所代表的存储空间的内容。值在函数中传递时会 copy 一个副本，也就是说传入函数后这个值和原来的变量就没有关系了，修改这个值不会影响原来变量的值，我们来看一个示例：
package main
import "fmt"
func main() {
var a int = 1
testfunc(a)
fmt.Printf("a=%d\n" a)
}
func testfunc(a int) {
a = a 1
}
输出结果：
a=1指针
在大学我们 C 语言的时候接触过指针的概念，golang 的指针和 C 语言的指针时一个含义，其内容是一段存储空间的地址。指针本身也是一个值，这不过这个值是一个存储空间的地址。然后函数参数传递的是一个指针，通过这个指针可以修改原来变量的值。我们把上面示例稍微修改一下在看看结果：
package main
import "fmt"
func main() {
var a int = 1
testfunc(&a)
fmt.Printf("a=%d\n" a)
}
func testfunc(a *int) {
*a = *a 1
}
输出结果：
a=2
另外需要特性强调的是，golang 的指针是一个阉割版的指针，golang 的指针是不支持运算的，指针本身的值是无法改变。golang 这么做是为了防止出现野指针（指针指向了非法的空间）。
下面代码在编译时就会报错
package main
import "fmt"
func main() {
var a int = 1
testfunc(&a)
fmt.Printf("a=%d\n" a)
}
func testfunc(a *int) {
a = a 1
}
报错信息
/main.go:12:10: cannot convert 1 (untyped int constant) to *int
其实 golang 的指针也并非是完全不能进行加减乘除运算的，但是需要先用 unsafe.pointer 把指针先转为整数，但是这目前不是本章的重点，后面我会写一篇专门的文档。
引用这是我们这一章节重点要说的，相信有很多人对引用的理解始终不是那么的透彻，大家第一次接触引用的概念应该是在大学学习 java 的时候，其行为和指针很像但是无论老师和课本都强调它不是指针，那么引用到底和指针有哪些区别呢。其实引用的引入是为了处理一些复杂数据类型的，如 golang 中的 slice，map，chan 等，为什么说这些数据类型复杂呢？我们就以 slice（切片）举例说明。
先看下面程序：
package main
import "fmt"
func main() {
a := []int{1 2 3}
fmt.Printf("value of a=%v; Lenght of a=%d; capacity of a=%d\n" a len(a) cap(a))
b := a[1:3]
fmt.Printf("value of b=%v; lenght of b=%d; capacity of b=%d\n" b len(b) cap(b))
}
输出结果：
value of a=[1 2 3]; lenght of a=3; capacity of a=3
value of b=[2 3]; lenght of b=2; capacity of b=2
我先来解释一下为什么 slice 是一种复杂类型，然后再回来分析上面的结果。所谓复杂类型，就是这种类型的变量自带一下“内禀属性”或者叫“内建属性”有或者可以叫“元数据”，这些属性的并不需要人工赋予，是语言自动添加的，slice 有三个内禀属性：Data，Len，Cap，在 reflect 中其对应的底层的结构体如下：
type SliceHeader struct {
Data uintptr
Len int
Cap int
}
- Data 是一个指针，指向了一段存储空间，这段存储空间用于存储 slice 数据的
- Len 表示当前 slice 的长度
- Cap 表示底层存储空间的容量
这样我们就很好理解上面的输出了：slice a 和 slice b 共用底层存储空间，所以它们的 Cap 属性值是一样的。
现在我们在回来看引用，之所以会用引用是因为引用所代表的变量背后的数据结构是复杂的，有很多属性是语言自动处理的（语言不希望我们来改变这些数据），在这种情况下使用指针明显是不合适的。
下面这张图详细解释了 golang 中哪些类型变量是值类型，哪些类型变量是引用类型。
另外需要特别注意的是 slice 和 map 分别对应的有两个内建函数 append 和 delete，append 用于向 slice 追加数据但是当 slice 底层存储空间不足时 append 会把原 slice 的底层数据 copy 一份放入新的地址空间追加的数据放入新的地址空间，也就是说使用 append 不会改变原来的数据，我们来看一个例子：
package main
import (
"fmt"
)
func main() {
a := []int{1 2}
testfunc(a)
fmt.Printf("a=%v\n" a)
}
func testfunc(a []int) {
a = append(a 3)
}
输出结果：
a=[1 2]
我们可以看到函数调用前后 a 的值没有变化。但是通过下面的方式改变函数里面 slice 的值，会影响到原来的变量：
package main
import (
"fmt"
)
func main() {
a := []int{1 2}
testfunc(a)
fmt.Printf("a=%v\n" a)
}
func testfunc(a []int) {
a[1] = 3
}
输出结果：
a=[1 3]
我接下来在看看 delete 是如何处理 map 的，直接看例子：
package main
import (
"fmt"
)
func main() {
a := map[int]string{1: "a" 2: "b"}
testfunc(a)
fmt.Printf("a=%v\n" a)
}
func testfunc(a map[int]string) {
delete(a 1)
}
输出结果：
a=map[2:b]
可以看到函数调用前后 map a 的值改变了，我们在来看一个向 map 中添加元素的例子：
package main
import (
"fmt"
)
func main() {
a := map[int]string{1: "a" 2: "b"}
testfunc(a)
fmt.Printf("a=%v\n" a)
}
func testfunc(a map[int]string) {
a[3] = "c"
}
输出结果：
a=map[1:a 2:b 3:c]
同样的，map a 的值被改变了。
那么引用的指针呢，会有什么现象？我们在看一个函数参数是引用类型变量的指针的例子：·
package main
import (
"fmt"
)
func main() {
a := []int{1 2}
testfunc(&a)
fmt.Printf("a=%v\n" a)
}
func testfunc(a *[]int) {
*a = append(*a 3)
}
输出结果：
a=[1 2 3]
可以看到 slice a 在函数调用前后有变化。
总结通过上面的例子大家能感受到 golang 数据类型的复杂，那么最后我就用一段话对上面这些现象及其原理做一下概括性解释。
golang 数据类型分为两大类：值类型和应用类型，如果函数参数是值类型，在函数调用时会 copy 一份数据，函数中改变数据不会改变原变量；如果函数参数时应用类型，在函数调用时只会 copy 引用本身并不会 copy 引用所代表的底层数据，但是在用 append 函数处理 slice 时，由于append 函数內部会 copy slice，所以通过 append 更改 slice 时不会影响原值，处理 map 的 delete 并不会 copy 数据所以会影响到原变量。对于指针，无论值类型的指针还是引用类型的指针都会改变原变量。
