day07 指针

指针

什么是指针

• * 取出指针变量中的值
• & 取地址符号

package main

import "fmt"

func main() {
	/*
		指针：
			- * 取出指针变量中的值
			- & 取地址符号

	*/

	// 1. 了解指针指向问题，指针取值
	var a int = 10
	// 将 a变量的内存地址  赋值给 b变量
	b := &a
	fmt.Printf("a 类型：%T, 地址：%p\n", a, &a) // a 类型：int, 地址：0xc000012098
	fmt.Printf("b 类型：%T, 地址：%p\n", b, &b) // b 类型：*int, 地址：0xc000058020
	fmt.Println(b)                        // 0xc00009e018

	// 通过 * 符号 获取 b 指针变量数据。
	fmt.Println("获取指针变量b的结果：", *b)

	// 修改指针变量b，即a变量数据也跟修改
	*b = 20
	fmt.Println("修改后的a：", a)
	fmt.Println("修改后的b：", *b)
}

指针使用

• 定义指针变量
• 为 指针变量赋值
• 访问指针变量中地址的值

package main

import "fmt"

func main() {
	/* 使用指针
	1. 定义指针变量
	2. 为 指针变量赋值
	3. 访问指针变量中地址的值
	*/

	// 定义指针
	var a int = 10
	var ptr *int
	ptr = &a
	fmt.Printf("ptr 指针变量存储地址：%p\n", ptr)
	fmt.Printf("ptr 指针变量自己地址：%p\n", &ptr)
	fmt.Printf("ptr 指针变量存储地址取值：%d\n", *ptr)

	// 指针套娃
	var ptr2 **int
	ptr2 = &ptr
	fmt.Printf("ptr2 指针的指针变量存储地址：%p\n", ptr2)
	fmt.Printf("ptr2 指针的指针变量自己地址：%p\n", &ptr2)
	fmt.Printf("ptr2 指针的指针变量存储地址取值：%d\n", **ptr2)

	// 修改 a 变量 ptr 和 ptr2 都会修改
	a = 20
	fmt.Printf("a的值：%d\n", a)
	fmt.Printf("ptr的值：%d\n", *ptr)
	fmt.Printf("ptr2的值：%d\n", **ptr2)
	**ptr2 = 40
	fmt.Printf("a的值：%d\n", a)
	fmt.Printf("ptr的值：%d\n", *ptr)
	fmt.Printf("ptr2的值：%d\n", **ptr2)

}

指针和数组

• 数组的指针`。 即：指针指向数组变量

package main

import "fmt"

func main() {

	/* `数组的指针`。 即：指针指向数组变量 */
	arr := [3]int{1, 2, 3}
	fmt.Println("数组arr:", arr)
	fmt.Printf("数组arr内存地址:%p\n", &arr)

	var ptr *[3]int // 指针数组变量
	ptr = &arr
	fmt.Printf("指针ptr存储的数组内存地址:%p\n", ptr)
	fmt.Printf("指针ptr存储的自己内存地址:%p\n", &ptr)
	fmt.Printf("指针ptr存储的数组取值:%v\n", *ptr)

	// 通过ptr 数组指针 修改 arr数组数据
	(*ptr)[0] = 100
	fmt.Println(arr)

	// ptr 指向了数组，可以直接使用ptr 操作数组。【语法糖】
	ptr[0] = 200 // ptr 指针变量指向 arr，操作ptr可以不使用 *
	fmt.Println(arr)

	/* `指针的数组` 。 即：数组中保存指针的变量 */
	a := 111
	b := 222
	c := 333
	d := 444

	arr1 := [4]*int{&a, &b, &c, &d}
	fmt.Println(arr1)
	// 修改 a的值
	fmt.Println("修改 前 指针数组：arr1 中 a变量的数据", a)
	fmt.Println("修改 前 指针数组：arr1 中 a变量的数据", *arr1[0])
	*arr1[0] = 1000
	fmt.Println("修改 后指针数组：arr1 中 a变量的数据", a)
	fmt.Println("修改 后指针数组：arr1 中 a变量的数据", *arr1[0])

}

指针函数

• 指针函数：函数的返回结果为指针类型

package main

import "fmt"

func ptrFunc() *[4]int {
	// 定一个 数组
	ptrArr := [4]int{1, 2, 3, 4}
	return &ptrArr // 函数返回 ： 数组地址
}

func main() {
	/*指针函数：函数的返回结果为指针类型*/

	ptrFuncRes := ptrFunc()
	fmt.Println("打印函数结果：", ptrFuncRes) // 返回的是一个指针类型的变量
	fmt.Printf("指针函数结果类型：%T\n", ptrFuncRes)
	fmt.Printf("指针函数结果变量ptrFuncRes自己的地址：%p\n", &ptrFuncRes)
	fmt.Printf("指针函数结果取值：%v\n", *ptrFuncRes)

	// 修改 res 指针函数结果。 方式一通过指针：*ptrFuncRes 取出数组修改
	fmt.Println("修改前:", (*ptrFuncRes)[0])
	fmt.Println(*ptrFuncRes)
	(*ptrFuncRes)[0] = 222
	fmt.Println("修改前:", (*ptrFuncRes)[0])
	fmt.Println(*ptrFuncRes)
	fmt.Println("-----")
	// ptrFuncRes 默认指向 数组结果
	fmt.Println("修改前:", ptrFuncRes[0])
	fmt.Println(*ptrFuncRes)
	ptrFuncRes[0] = 333
	fmt.Println("修改前:", ptrFuncRes[0])
	fmt.Println(*ptrFuncRes)
}

指针作为函数的参数

• 指针变量作为函数的参数

package main

import "fmt"

func updatePtrParamsFunc(ptr *int) int {
	fmt.Println("指针参数 ptr 修改前：", ptr)
	fmt.Printf("指针参数 ptr 修改前 类型:%T\n", ptr)
	fmt.Printf("指针参数 ptr 修改前 变量地址:%p\n", &ptr)
	*ptr = 100
	fmt.Println("指针参数 ptr 修改后：", ptr)
	fmt.Printf("指针参数 ptr 修改后 类型:%T\n", ptr)
	fmt.Printf("指针参数 ptr 修改后 变量地址:%p\n", &ptr)
	return *ptr
}

func updatePtrParamsFunc2(ptrArr *[3]int) {
	fmt.Println("指针参数 ptrArr 修改前：", ptrArr)
	fmt.Printf("指针参数 ptrArr 修改前 类型:%T\n", ptrArr)
	fmt.Printf("指针参数 ptrArr 修改前 变量地址:%p\n", &ptrArr)
	ptrArr[0] = 100
	fmt.Println("指针参数 ptr 修改后：", ptrArr)
	fmt.Printf("指针参数 ptr 修改后 类型:%T\n", ptrArr)
	fmt.Printf("指针参数 ptr 修改后 变量地址:%p\n", &ptrArr)
}

func main() {
	/* 指针变量作为函数的参数*/
	var num = 10
	updatePtrParamsFunc(&num)
	fmt.Println(num)

	var array = [3]int{1, 2, 3}
	updatePtrParamsFunc2(&array)
	fmt.Println(array)
}