Go的指针

本文探讨了Go语言中的指针概念及其代表形式,包括uintptr类型和unsafe包中的Pointer。文中详细列举了不可寻址的值类型,并解释了它们在实际编程中的使用限制。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

GO 的指针

一、GO中代表指标的几种东西

###(1)基本值的指针值

从传统意义上说,指针是一个指向某个确切的内存地址的值,这个内存地址可以是任何数据或代码的起始地址,

type Dog struct {
	name string
}

func (dog *Dog) SetName(name string) {
	dog.name = name
}

对于基本类型Dog来说,*Dog就是它的指针类型。对于一个Dog类型,值不为nil的变量dog,取值表达式&dog的结果就是该变量的值(也就是基本值的)指针值。

(2)uintptr 类型

uintptr类型是一个数值类型,也是GO语言内建的数据类型之一。根据当前计算机的计算架构不同,它可以存储32位或64位的无符号整数,可以代表任意指针的位(bit)模式,也就是原始的内存地址。

(3)Go语言标准库中的unsafe包:unsafe#Pointer

unsafe.Pointer可以表示任何指向可寻址的值的指针,同时它也是前面提到的指针值和uintpter值之间的桥梁。

也就是说,通过它,可以在这两个值之上进行双向的转换。

二、GO语言中哪些值是不可以寻址的

  • 常量的值
  • 基本类型值的字面量
  • 算术操作的结果值
  • 对各种字面量的索引表达式和切片表达式的结果值。不过有一个例外,对切片字面量的索引结果值却是可寻址的。
  • 对于字符串变量的索引表达式和切片表达式的结果值。
  • 对字典变量索引表达式的结果值;
  • 函数字面量和方法字面量,以及对它们的调用表达式的结果值;
  • 结构体字面量的字段值,也就是结构体字面量的选择表达式的结果值;
  • 类型转换表达式的结果值;
  • 类型断言表达式的结果值;
  • 接收表达式的结果值;

(1)常量的值

常量的值总是会被存储到一个确切的内存区域中,并且这种值肯定是不可变的。

	// 常量值总是会被存储到一个确切的内存区域中,并且这种值肯定是不可变的。
	const num = 123
	// _ = &num  // 寻址不可取

(2)基本类型的字面量

基本类型的字面量也是一样的,其实它们本就可以被视为常量,只不过没有任何标识符可以代表它们罢了。

	// _ = &(123) // 基本类型的字面量不可寻址

(3)第一个关键词:不可变的

由于GO语言中的字符串值也是不可变的,所以对一个字符串类型的变量来说,基于它的索引或切片的结果值也都是不可寻址的,因为即使拿到这种内存地址也改变不了什么。

	var str = "abc"
	_ = str
	// _ = &(str[0]) // 对字符串变量的索引结果值不可寻址
	// _ = &(str[0:1]) // 对字符串变量的切片结果值不可寻址
	str02 := str[2]
	_ = &str02 // 但这样的寻址就是合法的

(4)第二个关键词:临时结果

算术操作的结果是一种临时结果。在我们把结果赋给任何变量或常量之前,即使拿到它的内存地址也是没有任何意义的。

	const num = 123
	// _ = &(123 + 456) // 算术操作的结果值不可寻址
	num2 := 456
	_ = num2
	// _ = &(num + num2) // 算术操作的结果值不可寻址

我们把各种对值字面量施加的表达式的求值结果都看做是临时结果。

Go的表达式有很多种,常用的包括以下几种:

  • 用于获取某个元素的索引表达式;
  • 用于获取某个切片(片段)的切片表达式;
  • 用于访问某个字段的选择表达式;
  • 用于调用某个函数或方法的调用表达式;
  • 用于转换值的类型的类型转换表达式;
  • 用于判断值的类型的类型断言表达式;
  • 向通道发送元素值或从通道那里接收元素值的接收表达式;

我们把上述表达式施加在一个字面量上一般都会得到一个临时结果。

	// _ = &([3]int{1, 2, 3}[1]) // 对数组字面量的索引结果值不可寻址
	// _ = &([3]int{1, 2, 3}[0:1]) // 对数组字面的切片结果值不可寻址
	_ = &([]int{1, 2, 3}[0]) // 对切片的字面量的索引结果却是可寻址的
	// _= &([]int{1, 2,3}[0:2]) // 对切字面量的切片结果值不可寻址
	// _ = &(map[int]string{0:"aa"}[0]) // 对字面字面量的索引结果值不可寻址

特别注意:对切片字面量的索引结果值是可寻址的。 因为不论怎样,每个切片值都会持有一个底层数组,而这个底层数组中的每个元素值都是有一个确切的内存地址。

但是对切片字面量的切片结果值却是不可寻址的,这是因为切片表达式总会返回一个新的切片值,而这个新的切片值在给赋给变量之前属于临时结果。

如果针对的不是数组值、切片值或字典值的字面量的表达式,而是针对的数组类型或切片类型的变量,那么索引或切片的结果值就都不属于临时结果了,是可寻址的。这主要是因为变量本身不是“临时的”。

(5)第三个关键词:不安全的

对字典变量的索引结果值不可寻址

	var map01 = map[int]string{1: "a", 2: "b", 3: "c"}
	_ = map01
	// _ = &(map01[1]) // 对字典变量的索引结果值不可寻址

字典每个“‘键-元素”对的存储位置都可能会变化,而且这种变化外界是无法感知的。

字典中总会有若干个哈希桶用于均匀的存储键-元素对。当满足一定条件时,字典可能会改变哈希桶的数量,并适时地其中的键-元素对搬运到对应的新的哈希桶中。

这种情况下,获取字典中的任何元素值的指针都是无意义的,也是不安全的。

(6)函数和方法都是不可寻址的

一个原因是函数就是代码,是不可变的。另一个原因是,拿到一段代码的指针是不安全的。

此外,对函数或方法的调用结果值也是不可寻址的,这是因为它们都属于临时结果。

	// _ = &(func(x, y int) int {
	// 	return x + y
	// })   // 字面量代表的函数不可寻址

	// _ = &(fmt.Sprint) // 标识符代表的函数不可寻址

	// _ = &(fmt.Sprintln("aa")) // 对函数调用的结果值不可寻址
type Named interface {
	Name() string
}

type Dog struct {
	name string
}

func (dog *Dog) SetName(name string) {
	dog.name = name
}

func (dog Dog) Name() string {
	return dog.name
}
	dog := Dog{"little pig"}
	_ = dog
	// _ = &(dog.Name) // 标识符代表的函数不可寻址
	// _ = &(dog.Name())  // 对方法的调用结果值不可寻址

	// _ = &(Dog{"little pig"}.name) // 对结构体字面量的字段不可寻址

类型转换和断言:

	// _ = &(interface{}(dog)) // 类型转换表达式的结果值不可寻址
	dogI := interface{}(dog)
	_ = dogI
	// _ = &(dogI.(Named))  // 类型断言表达式的结果值不可寻址
	named := dogI.(Named)
	_ = named
	// _ = &(named.(Dog)) // 类型断言表达式的结果值不可寻址

(7)管道接收表达式的结果值不可寻址

	var ch chan int = make(chan int, 1)
	ch <- 1
	// _ = &(<- ch) //  接收表达式的结果值不可寻址

三、不可寻址值在使用上的限制

  • 无法使用取值符号&获取它们的指针;
  • 不能调用不可寻址值的指针方法;
type Dog struct {
	name string
}

func (dog *Dog) SetName(name string) {
	dog.name = name
}

func (dog Dog) Name() string {
	return dog.name
}

func New(name string) Dog {
	return Dog{name}
}
	p := New("Big pig")
	p.SetName("mon")
	// New("Big pig").SetName("mon") // 不可寻址,链式调用出错
  • 对于++-- 有一个重要限制,表达式的结果必须是可寻址的,

  • 这里有一个例外,虽然字典字面量和字典索引表达式的结果值是不可寻址的,但是这样的表达式却可以被用在自增语句和自减语句中

    	map[string]int{"a": 2}["a"]++
    	var m map[string]int  = map[string]int{"b":2}
    	m["b"]++
    
  • 对于赋值语句,赋值操作符左边的表达式的结果值必须是可寻址的,但是对字典索引结果值也是可以的

    	var m01 map[string]int = map[string]int{"a": 2}
    	m01["a"] = 3
    
  • 同样,对于带有range的for语句,rang左边的表达式的结果值必须是可寻址的。不过对字典的索引结果同样可以用在这里

    	var m01 map[string]int = map[string]int{"a": 2}
    	for mk := range m01 {
    		fmt.Println(m01[mk])
    	}
    

四、通过unsafe.Pointer 操作可寻址的值

首先说明,这是一项黑科技,它可以绕过GO语言的编译器和其他工具的重新检查,并达到潜入内存修改数据1目的。这并不是一种正常的编程手段,使用它会很危险,很有可能造成安全隐患。

我们总是应该优先使用常规代码包中提供的API去编写程序,当然也可以把reflect以及go/ast这样的代码包作为备选项。作为上层应用的开发者,请谨慎使用unsafe 包中的任何程序实体。

type Dog struct {
	name string
}

func main() {
	dog := Dog{"little pig"}
	dogP := &dog
	dogPtr := uintptr(unsafe.Pointer(dogP))
	fmt.Println(dogPtr)
}

转换规则:

  • 一个指针值(比如*Dog类型的值)可以被转换为一个unsafe.Pointer类型的值,反之依然;
  • 一个uintptr 类型的值也可以被转换为一个unsafe.Pointer 类型的值,反之依然;
  • 一个指针值无法直接转换为uintptr 类型的值,反之依然;

通过dogPtr可以获取字段的指针值:

	namePtr := dogPtr + unsafe.Offsetof(dog.name)
	nameP := (*string)(unsafe.Pointer(namePtr))
	fmt.Println(nameP)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值