目录
我们先看一个示例：仔细分析他们之间的区别：
看一下这段代码，你们觉得他会打印出几呢？
那我们一起手动运行一下
首先我们得到var a，然后给a分配一个内存地址，存入a的值1，如下图
然后呢我们通过changeValue传a进去，到changeValue得到形参p，初始值为0，也会为p开辟一块内存，接着，让p=a，如下图（p的内存值会从0变成1（忘了修改））
然后将p=10，那么此时p的值变成了10，a的值呢？他并没有变。如下图
所以这就是个值传递，a的值不会发生变化的，所以打印出a=1 。
那么如何才能让a的值发生改变呢？接下来请看下面一段代码
其中&a表示传的是a的地址，*int表示p是一个指针类型的int，*p呢指的是改变指针p所指向的那块内存。接着来看吧
第二步：
第三步：
很显然，这时a的值就做了改变。
好了我们来看个程序吧，注释的那段函数就不会改变ab的值
所以我们就引入了指针的概念：
一、指针1.1 指针的概念
指针是存储另一个变量的内存地址的变量。
我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。
一个指针变量可以指向任何一个值的内存地址它指向那个值的内存地址。
1.2 获取变量的地址
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
package main
import "fmt"
func main() {
var a int = 10
fmt.Printf("变量的地址: %x\n", &a )
}
运行结果：
变量的地址: 20818a220
1.3 声明指针
数组指针：首先是一个指针，一个数组的地址。
*[4]Type
指针数组：首先是一个数组，存储的数据类型是指针
[4]*Type
*[5]float64,指针，一个存储了5个浮点类型数据的数组的指针
*[3]string，指针，数组的指针，存储了3个字符串
[3]*string，数组，存储了3个字符串的指针地址的数组
[5]*float64，数组，存储了5个浮点数据的地址的数组
*[5]*float64，指针，一个数组的指针，存储了5个float类型的数据的指针地址的数组的指针
*[3]*string，指针，存储了3个字符串的指针地址的数组的指针
**[4]string，指针，存储了4个字符串数据的数组的指针的指针
**[4]*string，指针，存储了4个字符串的指针地址的数组，的指针的指针
声明指针，*T是指针变量的类型，它指向T类型的值。
var var_name *var-type
var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。
var ip *int /* 指向整型*/
var fp *float32 /* 指向浮点型 */
示例代码：
package main
import "fmt"
func main() {
var a int= 20 /* 声明实际变量 */
var ip *int /* 声明指针变量 */
ip = &a /* 指针变量的存储地址 */
fmt.Printf("a 变量的地址是: %x\n", &a )
/* 指针变量的存储地址 */
fmt.Printf("ip 变量的存储地址: %x\n", ip )
/* 使用指针访问值 */
fmt.Printf("*ip 变量的值: %d\n", *ip )
}
运行结果：
a 变量的地址是: 20818a220
ip 变量的存储地址: 20818a220
*ip 变量的值: 20
示例代码：
package main
import "fmt"
type name int8
type first struct {
a int
b bool
name
}
func main() {
a := new(first)
a.a = 1
a.name = 11
fmt.Println(a.b, a.a, a.name)
}
运行结果：
false 1 11
package main
import "fmt"
type name int8
type first struct {
a int
b bool
name
}
func main() {
var a = first{1, false, 2}
var b *first = &a
fmt.Println(a.b, a.a, a.name, &a, b.a, &b, (*b).a)
}
运行结果：
false 1 2 &{1 false 2} 1 0xc042068018 1
获取指针地址在指针变量前加&的方式
1.4 空指针
Go 空指针 当一个指针被定义后没有分配到任何变量时，它的值为 nil。 nil 指针也称为空指针。 nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。 一个指针变量通常缩写为 ptr。
空指针判断：
if(ptr != nil) /* ptr 不是空指针 */
if(ptr == nil) /* ptr 是空指针 */
1.5 获取指针的值
获取一个指针意味着访问指针指向的变量的值。语法是：*a
示例代码：
package main
import (
"fmt"
)
func main() {
b := 255
a := &b
fmt.Println("address of b is", a)
fmt.Println("value of b is", *a)
}
1.6 操作指针改变变量的数值
示例代码：
package main
import (
"fmt"
)
func main() {
b := 255
a := &b
fmt.Println("address of b is", a)
fmt.Println("value of b is", *a)
*a++
fmt.Println("new value of b is", b)
}
运行结果
address of b is 0x1040a124
value of b is 255
new value of b is 256
1.7 使用指针传递函数的参数
示例代码
package main
import (
"fmt"
)
func change(val *int) {
*val = 55
}
func main() {
a := 58
fmt.Println("value of a before function call is",a)
b := &a
change(b)
fmt.Println("value of a after function call is", a)
}
运行结果
value of a before function call is 58
value of a after function call is 55
不要将一个指向数组的指针传递给函数。使用切片。
假设我们想对函数内的数组进行一些修改，并且对调用者可以看到函数内的数组所做的更改。一种方法是将一个指向数组的指针传递给函数。
示例代码：
package main
import (
"fmt"
)
func modify(arr *[3]int) {
arr[0] = 90
}
func main() {
a := [3]int{89, 90, 91}
modify(&a)
fmt.Println(a)
}
运行结果
[90 90 91]
虽然将指针传递给一个数组作为函数的参数并对其进行修改，但这并不是实现这一目标的惯用方法。我们有切片。
示例代码：
package main
import (
"fmt"
)
func modify(sls []int) {
sls[0] = 90
}
func main() {
a := [3]int{89, 90, 91}
modify(a[:])
fmt.Println(a)
}
运行结果：
[90 90 91]
Go不支持指针算法。
package main
func main() {
b := [...]int{109, 110, 111} p := &b p++ }nvalid operation: p++ (non-numeric type *[3]int)
指针数组
package main
import "fmt"
const MAX int = 3
func main() {
a := []int{10,100,200}
var i int
for i = 0; i < MAX; i++ {
fmt.Printf("a[%d] = %d\n", i, a[i] )
}
}
结果a[0] = 10
a[1] = 100
a[2] = 200
有一种情况，我们可能需要保存数组，这样我们就需要使用到指针。
package main
import "fmt"
const MAX int = 3
func main() {
a := []int{10,100,200}
var i int
var ptr [MAX]*int;
for i = 0; i < MAX; i++ {
ptr[i] = &a[i] /* 整数地址赋值给指针数组 */
}
for i = 0; i < MAX; i++ {
fmt.Printf("a[%d] = %d\n", i,*ptr[i] )
}
}
结果a[0] = 10
a[1] = 100
a[2] = 200
1.8 指针的指针
指针的指针
如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。
var ptr **int;
package main
import "fmt"
func main() {
var a int
var ptr *int
var pptr **int
a = 3000
/* 指针 ptr 地址 */
ptr = &a
/* 指向指针 ptr 地址 */
pptr = &ptr
/* 获取 pptr 的值 */
fmt.Printf("变量 a = %d\n", a )
fmt.Printf("指针变量 *ptr = %d\n", *ptr )
fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}
结果变量 a = 3000
指针变量 *ptr = 3000
指向指针的指针变量 **pptr = 3000
指针作为函数参数
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int= 200
fmt.Printf("交换前 a 的值 : %d\n", a )
fmt.Printf("交换前 b 的值 : %d\n", b )
/* 调用函数用于交换值
* &a 指向 a 变量的地址
* &b 指向 b 变量的地址
*/
swap(&a, &b);
fmt.Printf("交换后 a 的值 : %d\n", a )
fmt.Printf("交换后 b 的值 : %d\n", b )
}
func swap(x *int, y *int) {
var temp int
temp = *x /* 保存 x 地址的值 */
*x = *y /* 将 y 赋值给 x */
*y = temp /* 将 temp 赋值给 y */
}
结果交换前 a 的值 : 100
交换前 b 的值 : 200
交换后 a 的值 : 200
交换后 b 的值 : 100
1.9指针函数与函数指针
函数指针：一个指针，指向了一个函数的指针。
因为go语言中，function，默认看作一个指针，没有*。slice,map,function
指针函数：一个函数，该函数的返回值是一个指针。
示例代码：
package main
import "fmt"
func main() {
var a func()
a = fun1
a()
arr1 := fun2()
fmt.Printf("arr1的类型：%T，地址：%p，数值：%v\n",arr1,&arr1,arr1)
arr2 := fun3()
fmt.Printf("arr2的类型：%T，地址：%p，数值：%v\n",arr2,&arr2,arr2)
fmt.Printf("arr2指针中存储的数组的地址：%p\n",arr2)
}
func fun3()*[4]int{
arr := [4]int{5,6,7,8}
fmt.Printf("函数中arr的地址：%p\n",&arr)
return &arr
}
func fun2()[4]int{//普通函数
arr :=[4]int{1,2,3,4}
return arr
}
func fun1(){
fmt.Println("fun1().....")
}
运行结果：
fun1().....
arr1的类型：[4]int，地址：0xc0000a8060，数值：[1 2 3 4]
函数中arr的地址：0xc0000a80e0
arr2的类型：*[4]int，地址：0xc0000ce020，数值：&[5 6 7 8]
arr2指针中存储的数组的地址：0xc0000a80e0