一、指针简介

1.指针概念

指针也是一个变量，它是一种特殊的变量，因为它存储的数据不仅仅是一个普通的值，而是另一个变量的内存地址。

2.内存地址

变量p是一个指针，它存储的是变量a 的内存地址，而不是a的值。

二、指针的定义 

1.语法

var 指针变量名 *类型

package main
 
import "fmt"
 
func main()  {
	var a int = 10
	var p *int
	p = &a
    fmt.Println(&a) //变量a的内存地址
	fmt.Println(p)  //变量a的内存地址
	fmt.Println(*p) //变量a的值
    fmp.println(&p) //变量p的内存地址
}

 输出：

0xc0000aa058
0xc0000aa058
10
0xc0000ce018

2.通过指针间接修改变量的值

package main
 
import "fmt"
 
func main() {
	var a int = 10
	fmt.Println(a)
	var p *int = &a
	*p = 999
	fmt.Println(a)
}

输出：

10
999

三、指针操作的注意事项

1.空指针

package main
 
import "fmt"
 
func main() {
	var p *int
	fmt.Println(p)
}

输出：

 

2.不要操作没有合法指向的内存

package main
 
import "fmt"
 
func main() {
	var p *int
	*p = 56
	fmt.Println(p)
}

输出:

 panic: runtime error: invalid memory address or nil pointer dereference

3.new函数使用

package main
 
import "fmt"
 
func main() {
	var p *int
	//开辟数据类型对应的内存空间，返回值为数据类型的指针
	p = new(int)
	*p = 56
	fmt.Println(*p)
}

输出：

56

四、指针作为函数参数

在函数中修改变量值，怎样影响原有的变量？

package main
 
import "fmt"
 
func main() {
	var num int = 10
	Update(&num)
	fmt.Println(num)
}
func Update(p *int)  {
	*p = 999
}

 五、数组指针

1.概念与基本使用

package main
 
import "fmt"
 
func main() {
	nums := [10]int{1,2,3,4,5,6,7,8,9,10}
	var p *[10]int
	p =&nums
	fmt.Println(*p)
    fmt.Println((*p)[0]) //[]的运算优先级高于*
    fmt.println(p[0])  //go语言优势
}
 

输出：

 [1 2 3 4 5 6 7 8 9 10]
1
1

2.将数组指针作为函数参数

package main
 
import "fmt"
 
func main() {
	nums := [10]int{1,2,3,4,5,6,7,8,9,10}
	Update(&nums)
	fmt.Println(nums)
 
}
func Update(arr*[10]int)  {
	arr[0] = 999
}
 

输出：

[999 2 3 4 5 6 7 8 9 10]

六、指针数组

1.概念

数组元素是是指针类型

指针数组指的是一个数组中存储的都是指针（也就是地址），也就是一个存储了地址的数组。

2.基本操作

package main
 
import "fmt"
 
func main() {
	var P[2]*int
	var i,j int = 10, 20
	P[0] = &i
	P[1] = &j
	fmt.Println(P)
	fmt.Println(*P[0],",",*P[1])
}
 
 

输出：

[0xc0000aa058 0xc0000aa070]
10 , 20

七、指针与切片

1.概念

定义指针，指向切片

2.基本操作

package main
 
import "fmt"
 
func main() {
	s := []int{1,2,3,4,5}
	var p *[]int  = &s
	fmt.Println(*p)
	fmt.Println((*p)[0])
	//fmt.Println(p[0]) 不支持这样简写
 
	//修改值
	(*p)[0] = 999
	fmt.Println(*p)
 
	//循环遍历
	for i:=0;i<len(*p);i++{
		fmt.Print((*p)[i]," ")
	}
	fmt.Println()
	for index,value := range *p{
		fmt.Print(index,":",value,"  ")
	}
}
 
 

输出：

[1 2 3 4 5]
1
[999 2 3 4 5]
999 2 3 4 5 
0:999  1:2  2:3  3:4  4:5  

八、指针与结构体

1.概念

定义指针，指向结构体

2.基本操作

package main
 
import "fmt"
 
type Student struct {
	id int
	name string
	age int
	addr string
}
func main() {
	stu := Student{101,"Mike",18,"beijing"}
	var p *Student
	p = &stu
	fmt.Println(*p)
	fmt.Println((*p).id) // . 的优先级高于*
	fmt.Println(p.name)  //可以优化简写
	//修改结构体的值
	p.age = 20
	fmt.Println(*p)
}
 
 

输出：

{101 Mike 18 beijing}
101
Mike
{101 Mike 20 beijing}

3.作为函数参数

package main
 
import "fmt"
 
type Student struct {
	id int
	name string
	age int
	addr string
}
func main() {
	stu := Student{101,"Mike",18,"beijing"}
	Update2(stu)
	fmt.Println("未使用指针结果：",stu)
	Update1(&stu)
	fmt.Println("使用指针结果：",stu)
	
}
func Update1(stu *Student)  {
	stu.addr = "上海"
}
func Update2(stu Student)  {
	stu.addr = "上海"
}
 
 

输出：

未使用指针结果： {101 Mike 18 beijing}
使用指针结果： {101 Mike 18 上海}
 

九、多级指针

package main
 
import "fmt"
 
func main() {
	var a int = 10
	var p *int
	p = &a
	var pp **int
	pp = &p
	fmt.Println("a=",a," p=",p," *p=",*p," pp=",pp," *pp=",*pp," **pp=",**pp)
	**pp = 20
	fmt.Println(a)
}
 

输出：

a= 10  p= 0xc0000aa058  *p= 10  pp= 0xc0000ce018  *pp= 0xc0000aa058  **pp= 10
20