Go的指针

1、指针概念

指针也是一个变量，但它是一种特殊的变量，因为它存储的数据不仅仅是一个普通的值，如简单的整数或字符串，而是另一个变量的内存地址，如下图：

2、指针定义

package main

import "fmt"

func main() {

	var a int = 10
	var p *int
	p = &a
	fmt.Printf("%p\n", &a)
	fmt.Printf("%p\n", p)
	fmt.Printf("%d\n", *p)
}

输出结果：

0xc0000ac058
0xc0000ac058
10

注意事项：

3、new函数使用

package main

import "fmt"

func main() {
	var p *int
	p = new(int)
	*p = 67
	fmt.Println(*p)
}

4、指针作为函数参数

交互a、b的值

package main

import "fmt"

//func swap(a int, b int) {
//	a, b = b, a
//}
//函数参数为指针类型
func swap(a *int, b *int) {

	//*a  值
	//*a, *b = *b, *a
	temp := *a
	*a = *b
	*b = temp
}

func main() {

	a := 10
	b := 20
	//不能交换a b 的值  值传递
	//swap(a,b)
	//指针作为函数参数是地址传递
	swap(&a, &b)

	fmt.Println(a)
	fmt.Println(b)
}

输出结果：

20
10

5、数组指针

package main

import "fmt"

func main() {

	nums := [5]int{1, 2, 3, 4, 5}
	var p *[5]int
	p = &nums
	fmt.Println(*p)
	fmt.Println((*p)[0])

	updateArr(p)
	fmt.Println(p[0])
}

func updateArr(p *[5]int) {
	p[0] = 100
}

输出结果：

[1 2 3 4 5]
1  
100

6、指针数组

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

package main

import "fmt"

func main() {
	var p [2]*int
	var i int = 10
	var j int = 20
	p[0] = &i
	p[1] = &j
	fmt.Println(p)
	fmt.Println(*p[0])
}

输出结果：

[0xc0000120b8 0xc0000120d0]
10

7、切片指针

package main

import "fmt"

func main() {
	var slice []int = []int{1, 2, 3, 4, 5}

	//p:=&slice//*[]int
	var p *[]int //二级指针
	p = &slice

	fmt.Printf("slice 的地址 %p\n", &slice[0])
	fmt.Printf("p 的地址 %p\n", p)
	fmt.Printf("*p 的地址%p\n", *p)

	*p = append(*p, 6, 7, 8, 9, 10)

	fmt.Printf("append后slice 的地址%p\n", slice)
	fmt.Println(slice)
}

输出结果：

slice 的地址 0xc00000a390
p 的地址 0xc000004078           
*p 的地址0xc00000a390           
append后slice 的地址0xc000014140
[1 2 3 4 5 6 7 8 9 10]    

8、切片指针作为函数参数

package main

import "fmt"

func test(s *[]int) {
	*s = append(*s, 4, 5, 6)
}

func main() {
	s := []int{1, 2, 3}
	fmt.Printf("%p\n", s)
	//切片指针作为函数参数是地址传递  形参可以改变实参的值
	test(&s)

	fmt.Printf("%p\n", s)
	fmt.Println(s)
}

输出结果：

0xc00012a090
0xc000152030 
[1 2 3 4 5 6]

9、指针切片

package main

import "fmt"

func main() {
	//指针切片
	var slice []*int
	a := 10
	b := 20
	c := 30
	d := 40
	slice = append(slice, &a, &b, &c)

	slice = append(slice, &d)
	fmt.Println(slice)

	for i, v := range slice {
		//fmt.Printf("%T",v)
		fmt.Println(i, *v)
	}
}

输出结果：

[0xc0000120b8 0xc0000120d0 0xc0000120d8 0xc0000120e0]
0 10
1 20
2 30
3 40

10、结构体指针

package main

import "fmt"

type Student struct {
	name string
	id   int
	age  int
	sex  string
}

func updateStu(stu *Student) {
	stu.age = 21
}

func main() {
	var stu Student = Student{id: 101, name: "多啦A梦", age: 100, sex: "男"}

	var p *Student
	p = &stu

	//通过结构体指针间接操作结构体成员
	//(*p).name="大熊"
	//通过指针可以直接操作结构体成员
	p.name = "静香"
	p.age = 18
	p.sex = "女"

	fmt.Println(stu)

	updateStu(p)
	fmt.Println(*p)

	fmt.Println((*p).name)
	fmt.Println(p.name)

}

输出结果：

{静香 101 18 女}
{静香 101 21 女}
静香
静香

11、多级指针

package main

import "fmt"

var pp **int

func main() {
	a := 10
	p := &a
	pp := &p  //二级指针  二级指针存储一级指针的地址
	p3 := &pp //三级指针 存储二级指针的地址
	fmt.Println(p)
	fmt.Println(&p)
	println()

	//一级指针的值
	fmt.Println(*pp)
	fmt.Println(p)
	fmt.Println(&a)
	println()

	//变量a 的值
	fmt.Println(*p3)
	fmt.Println(**pp)
	fmt.Println(*p)
	fmt.Println(a)
	println()

	fmt.Printf("%T\n", a)
	fmt.Printf("%T\n", p)
	fmt.Printf("%T\n", pp)

}

输出结果：

0xc0000120b8
0xc000006028
            
0xc0000120b8
0xc0000120b8
0xc0000120b8
            
0xc000006028
10          
10          
10          
            
int         
*int        
**int