go语言指针类型的使用

2023年8月16日 179次阅读 来源: CodingCode

go语言的指针类型

简单地说go语言的指针类型和C/C++的指针类型用法是一样的，除了出去安全性的考虑，go语言增加了一些限制，包括如下几条：

  1. 不同类型的指针不能互相转化，例如*int, int32, 以及int64
  2. 任何普通指针类型*T和uintptr之间不能互相转化
  3. 指针变量不能进行运算, 比如C/C++里面的++, –运算

举例来说

package main

import ( "fmt" )

func main() {
   i1 := int(1)
   i2 := int32(1)
   i3 := int64(1)

   p1 := &i1
   p2 := &i2
   p3 := &i3

   p1 = (* int)(p2)
   p1 = (* int)(p3)

   p2 = (* int32)(p1)
   p2 = (* int32)(p3)

   p3 = (* int64)(p1)
   p3 = (* int64)(p2)

   p1 = p1 + 8

   fmt.Printf("p1=%p,p2=%p,p3=%p\n", p1, p2, p3);
}

go编译器会对所有的指针类型转换都报错，也对指针的运算报错了，如下：

$ go build main.go
# command-line-arguments
./main.go:14: cannot convert p2 (type *int32) to type *int
./main.go:15: cannot convert p3 (type *int64) to type *int
./main.go:17: cannot convert p1 (type *int) to type *int32
./main.go:18: cannot convert p3 (type *int64) to type *int32
./main.go:20: cannot convert p1 (type *int) to type *int64
./main.go:21: cannot convert p2 (type *int32) to type *int64
./main.go:23: invalid operation: p1 + 8 (mismatched types *int and int)

但是go语言同时也提供了一个unsafe.Pointer包，在它的帮助下，一切操作都是可行的了。不过请注意，这些操作都是不安全的，因为unsafe包里面提供的函数打破Go类型系统和内存管理的安全机制，需要使用者非常小心，这也就是其包名为什么叫做unsafe。

unsafe包

包unsafe提供了下面两条重要的指针相关的功能：

  • 任何类型的指针都可以被转换为unsafe.Pointer类型，反之亦然
  • 一个uintptr值可以被转换为unsafe.Pointer类型，反之亦然

对照前面提到的go语言对指针使用的限制，这两条扩展就是针对前面对指针使用的限制而定制扩展的。

通过第一条，使得指针类型之间的转换成为可能，先把原指针类型转换成unsafe.Pointer，然后再把unsafe.Pointer转化成目标指针类型。
再通过第二条，使得指针的运算成为可能，先把原指针转换unsafe.Pointer，再把unsafe.Pointer转化成uintptr，然后进行数值的运算，接着在把运算后的值转换回unsafe.Pointer，最后把unsafe.Pointer转换回对应的原始数据指针。

在这里补充对unsafe.Pointer和uintptr两种类型单独解释两句：

  • unsafe.Pointer是一个指针类型，指向的值不能被解析，类似于C/C++里面的(void *)，只说明这是一个指针，但是指向什么的不知道。
  • uintptr 是一个整数类型，这个整数的宽度足以用来存储一个指针类型数据；那既然是整数类类型，当然就可以对其进行运算了。

举一个使用例子

package main

import (
  "fmt"
  "unsafe"
)

func main() {
   var ii [4]int = [4]int{ 11, 22, 33, 44 }

   var p0 * int          = &ii[0]               // p0 point to first element
   var p1 unsafe.Pointer = unsafe.Pointer(p0)   // convert (* int) to unsafe.Pointer
   var p2 uintptr        = uintptr(p1)          // convert unsafe.Pointer to uintptr
   p2 += 8                                      // computing uintptr with plus 8, i.e, the next element address
   var p3 unsafe.Pointer = unsafe.Pointer(p2)   // convert uintptr back to unsafe.Pointer
   var p4 * int64        = (* int64)(p3)        // convert unsafe.Pointer to another type pointer, (* int64)

   fmt.Printf("*p0=%d,*p4=%d\n", *p0, *p4);
}

这个例子，定义了一个int数组，然后定义一个指向第一个元素的指针，接着运算这个指针，让它指向下一个元素，最后以int64的格式打印出下一个元素的值。

$ go build && ./main 
*p0=11,*p4=22

关于unsafe.Pointer的详细说明

请参考官方文档
https://golang.org/pkg/unsafe/#Pointer

    原文作者：CodingCode
    原文地址: https://www.jianshu.com/p/a934c466fa5c
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞