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)
}
输出：
<nil>
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
