GO指针详解

因为大一的时候c语言没学好,所以看到指针很心烦 ,后来速成了一遍go ,每每写道指针部分就开始遗忘 ,所以专门对指针部分做了此笔记

概念

在 Go 语言中，指针是一种变量类型，它存储的是另一个变量的内存地址。通过指针，你可以访问和修改它指向的内存位置上存储的数据。这和 Java 中的引用类型变量（如对象的引用）有相似之处，因为它们都允许通过一个“引用”或“指针”来操作实际的数据。在go中指针就是通过可以通过操作地址的方式实现引用传递的效果

指针是一个变量 和int int32 float32 uint64一样都是变量 只是该变量存储的是数据是地址

代码观察

/**
指针是变量 地址是变量的内存地址 是数据
指针可以理解为一个变量类型，可以指向其他变量的内存地址，通过指针可以修改其他变量的值。
如果传递一个非引用对象(java中的对象 java的对象名其实就是类似于指针的概念) 如果传递的是数据的话那么方法修改了 也不是会影响到原来的数据的
如果传递的是引用对象(java中的对象 java的对象名其实就是类似于指针的概念) 那么方法修改了 也会影响到原来的数据的
*/

func pointdemo() {

	a, b := 1, 2.34
	fmt.Println("输出变量a和b的值：")
	fmt.Println("a=", a, "b=", b)
	//输出:输出变量a和b的值：a= 1 b= 2.34
	fmt.Println("输出对应的地址：")

	fmt.Printf("a的地址：%p\n", &a)
	fmt.Printf("b的地址：%p\n", &b)
	//输出:a的地址：0xc00000a0d8
//b的地址：0xc00000a0f0
	// 创建指针
	var pA *int = &a
	pB := &b
	//是一样的 所以可以发现 指针的地址是一样的

/* 所以大一我就认为地址和指针是一个东西 导致后面接口 还有方法的时候会出很多问题
a的地址：0xc00000a0d8
b的地址：0xc00000a0f0
*/
	fmt.Printf("a的地址：%p\n", pA)
	fmt.Printf("b的地址：%p\n", pB)
//由于指针也是存储地址的变量 那么作为变量肯定也有自己的地址
	fmt.Printf("指针在取地址a的地址：%p\n", &pA)
	fmt.Printf("指针b的地址：%p\n", &pB)
	/*
	
	指针在取地址a的地址：0xc000060028
	指针b的地址：0xc000060030
	
	*/
	// 通过指针输出数据
	fmt.Println("通过指针输出a的值：", *pA)
	fmt.Println("通过指针输出b的值：", *pB)

	// 修改指针指向的数据
	*pA = 3
	*pB = 4.56
	fmt.Println("修改后的a和b的值：")
	//使用指针获取数值  对指针获取数据
	fmt.Println("指针方式a=", *pA, "b=", *pB)
	//使用地址获取数值 对地址获取数据
	fmt.Println("地址方式取数=", *(&a), "b=", *(&b))
/*
	这里就验证了指针可以通过*指针获取数据并且改变
	地址也可也可以通过这个符号改变 
*/

	*(&a) = 5
	*pB = 6.78

	fmt.Println("指针改变数值后a和b的值=", a, "b=", b)
}

错误笔记

上面讲了和java的类似 那么这里记录我的一个小错误

	fmt.Println("请输入一个字符串：")
	var input string
	scanln, err := fmt.Scanln(&input)
		fmt.Println(input)

既然可以通过传递地址然后输入的数值赋予变量 那么我传递指针也是一样的吧?

	var name *string

	fmt.Println("请输入一个字符串：")
	fmt.Scanln(name)
	fmt.Println("输入的数据：", *name)
	fmt.Println("输入的读取的单位数 这里是行为：", scanln)

运行

无效的地址指针
这里我就突然忘记了
指针既然是变量 那么是需要初始化的 不初始化只是有一个地址 地址没有指向任何一个空间 所以无法把输入的值传递给他 所以指针线初始化指向一个变量的地址 这里scan赋值过程就变成了 用户输入值->指针地址->找到指针装载的值(地址)->通过地址找到这个变量的内存空间进行修改

demo := "初始化"
   var name *string = &demo

   fmt.Println("请输入一个字符串：")
   fmt.Scanln(name)
   fmt.Println("输入的数据：", *name)

指针分类

二重

在go中,数组算是基本数据类型 ,即参数传递的过程中,传递的是引用,函数修改参数,原来的数据发生改变,而go中并不会这样,所以需要数组指针来完成这个操作

func main() {
	var a int = 10
	var b *int = &a
	*b = 20
	fmt.Println("a = ", a) // Output: a = 20

	fmt.Printf("value of a  %p\n ", b)    // Output: a = int
	fmt.Printf("type of b  %T\n ", b)     // Output: b = 0xc000014080
	fmt.Printf("address of b  %p\n ", &b) // Output: b = 0xc000014080
	c := 12
	d := 20
	e := &c
	f := &d

	add(&c, &d)
	fmt.Printf("c =%d\n d=%d\n", c, d) // Output: c = 32	d=20  传递数值地址 改变数值地址也会改变
	swap(e, f)                   
	//并没有交换
	fmt.Printf("c =%d\n d=%d\n", *e, *f) // Output: c = 32	d=20  传递数值地址 改变数值地址也会改变

}

// 交换地址
func swap(i *int, i2 *int) {
	i, i2 = i2, i
}

/*
*
指针作为参数
*/
func add(a, b *int) {
	*a = *a + *b
}

swap 这里测试通过函数修改参数,影响原数据,一般数据可以通过传递地址修改来影响原来数据,指针也是一样的
这里和函数哪里交换函数体是一样的,传递数据地址可以改变原数据的内容,那么这里想要哦通过改变指针存放的地址,来影响原来的数据,那么就要传递的数据,那么就传递这个指针的地址既即可完成交换(二重指针)

func main() {
	var a int = 10
	var b *int = &a
	*b = 20
	fmt.Println("a = ", a) // Output: a = 20

	fmt.Printf("value of a  %p\n ", b)    // Output: a = int
	fmt.Printf("type of b  %T\n ", b)     // Output: b = 0xc000014080
	fmt.Printf("address of b  %p\n ", &b) // Output: b = 0xc000014080
	c := 12
	d := 20
	e := &c
	f := &d

	add(&c, &d)
	fmt.Printf("c =%d\n d=%d\n", c, d) // Output: c = 32	d=20  传递数值地址 改变数值地址也会改变
	swap(&e, &f)                       //传递指针的1地址 完成交换
	//完成交换
	fmt.Printf("c =%d\n d=%d\n", *e, *f) // Output: c = 20	d=32  传递数值地址 改变数值地址也会改变

}

//接收指针的地址  
func swap(i **int, i2 **int) {
//改变指针地址存放的内容
	*i, *i2 = *i2, *i//地址取值 就是一种指针(一重地址的空间) 数值是书数据地址 
}

/*
*
指针作为参数
*/
func add(a, b *int) {
	*a = *a + *b
}

数组指针

由于go中的数组是基本类型 所以智能通过指针实现修改参数 改变原来的数值

func main() {

	//数组指针
	var arr [5]int
	var ptr *[5]int
	ptr = &arr
	(*ptr)[0] = 10
	(*ptr)[1] = 20
	(*ptr)[2] = 30
	(*ptr)[3] = 40
	(*ptr)[4] = 50
	//for i := 0; i < len(arr); i++ {
	//	fmt.Print(arr[i], " ")
	//}
	fmt.Println(ptr)
	//fmt.Println("之前", arr)
	//array(arr)
	//fmt.Println("之后", arr)
	fmt.Println("之前", arr)
	array2(ptr)
	fmt.Println("之后", arr)
	/**
	指针数组
	*/

	var arr2 [5]*int
	arr2 = [...]*int{
		&arr[0],
		&arr[1],
		&arr[2],
		&arr[3],
		&arr[4],
	}
	//每一个元素都是指针
	fmt.Println(*arr2[0])
}
func array(arr [5]int) {
	arr[0] = 200
}
func array2(arr *[5]int) {
	arr[0] = 200
}

函数指针

可以详情查看go中的数据类型 —函数

func main() {
	f := func(a int, b int) {
		fmt.Println(a + b)
	}
	fmt.Println("已知函数本身就可以看作存储函数体地址的指针", f)
	fmt.Println("函数取地址就像多重指针", &f)
	//a2 := []int{12, 34, 56}
	//c := &a2

}