How to implement pointer conversion in golang

In golang, you can use the unsafe package to implement pointer conversion and convert memory addresses between different pointer types, thereby operating memory more flexibly. For example, the Pointer() function under the unsafe package can convert the address of any variable into a Pointer type, or convert the Pointer type into any pointer type. The Pointer type is an intermediate type for conversion between different pointer types.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

In golang, you can use the unsafe package to implement pointer conversion.

Golang’s pointer conversion

Golang provides the unsafe package, allowing us to directly operate the memory at the specified memory address.

Under the unsafe package, there is a definition of type Pointer *ArbitraryType (pointer of any type), which can bypass the type restrictions of GO, type ArbitraryType int

• Any type of pointer value All can be converted to Pointer.

• Pointer can be converted to any type of pointer value.

• uintptr can be converted to Pointer.

• Pointer can be converted to uintptr.

Through the unsafe.Pointer() function, we can obtain the memory address representation of the variable, which is essentially an integer. The address of any variable can be converted into a Pointer type, or the Pointer type can be converted into any pointer type. It is an intermediate type for conversion between different pointer types.

But Pointer does not support operations. If you want to perform addition and subtraction operations on the memory address, you need to convert it to uintptr type.

Below we try to read the slice address and traverse its contents through memory operations:

package main

import "fmt"
import "unsafe"

func main() {
	// head = {address, 10, 10}
	// body = [1,2,3,4,5,6,7,8,9,10]
	var s = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	var address = (**[10]int)(unsafe.Pointer(&s))
	var len = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(8)))
	var cap = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(16)))
	fmt.Println(address, *len, *cap)
	var body = **address
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", body[i])
	}
}
----------
0xc000004460 10 10
1 2 3 4 5 6 7 8 9 10

In the above code:

• unsafe.Pointer(&s) Gets the memory address of the first position represented by the underlying representation of slice s, that is, the address storage address of the underlying array,

  passes (**[10]int)(unsafe .Pointer(&s)) to convert it into an **[10]int type pointer, and then restore it to an array through **addrss;

• ##unsafe.Pointer(uintptr(unsafe.Pointer( &s)) uintptr(8)) Through address operation, obtain the storage address of length,
  and then through (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) uintptr(8))) Convert the length memory to an int pointer
  Finally get the slice length through *len;
  The operation of cap is similar to len and will not be described again;

In short:

Through unsafe, we can convert memory addresses between different pointer types, thereby operating memory more flexibly;

This experiment also further verified the underlying storage structure of the slice;

unsafe should be used sparingly when it is not necessary. Directly operating memory is risky after all;

[Related recommendations:

Go video tutorial、programming teaching】

The above is the detailed content of How to implement pointer conversion in golang. For more information, please follow other related articles on the PHP Chinese website!