Comment implémenter la conversion de pointeur dans Golang

Dans Golang, vous pouvez utiliser le package non sécurisé pour implémenter la conversion de pointeur et convertir les adresses mémoire entre différents types de pointeurs, exploitant ainsi la mémoire de manière plus flexible. Par exemple, la fonction Pointer() du package unsafe peut convertir l'adresse de n'importe quelle variable en type Pointer, ou convertir le type Pointer en n'importe quel type de pointeur. Le type Pointer est un type intermédiaire pour la conversion entre différents types de pointeur.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Dans Golang, vous pouvez utiliser le package non sécurisé pour implémenter la conversion de pointeur.

Conversion du pointeur de Golang

Golang fournit le package non sécurisé, nous permettant d'exploiter directement la mémoire à l'adresse mémoire spécifiée.

Sous le package non sécurisé, il existe une définition du type Pointer *ArbitraryType (pointeur de n'importe quel type), qui peut contourner les restrictions de type de GO Type ArbitraryType int

• Tout type de valeur de pointeur peut être converti en pointeur.

• Le pointeur peut être converti en n’importe quel type de valeur de pointeur.

• uintptr peut être converti en pointeur.

• Le pointeur peut être converti en uintptr.

Grâce à la fonction unsafe.Pointer(), nous pouvons obtenir la représentation de l'adresse mémoire de la variable, qui est essentiellement un entier. L'adresse de n'importe quelle variable peut être convertie en type Pointeur, ou le type Pointeur peut être converti en n'importe quel type de pointeur. Il s'agit d'un type intermédiaire pour la conversion entre différents types de pointeur.

Mais Pointer ne prend pas en charge les opérations. Si vous souhaitez effectuer des opérations d'addition et de soustraction sur l'adresse mémoire, vous devez la convertir en type uintptr.

Ci-dessous, nous essayons de lire l'adresse de la tranche et de parcourir son contenu via des opérations de mémoire :

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

Dans le code ci-dessus :

• unsafe.Pointer(&s) récupère la mémoire de la première position de la représentation sous-jacente de slice s L'adresse, c'est-à-dire l'adresse du tableau sous-jacent, est convertie en un pointeur de type **[10]int via (**[10]int)(unsafe.Pointer(&s)), et restaurée en * *addrss via **addrss Array;

unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(8)) Grâce à l'opération d'adresse, obtenez l'adresse de stockage de longueur,

• puis via (*int )(unsafe.Pointer(uintptr( unsafe.Pointer(&s)) + uintptr(8))) Convertir la mémoire de longueur en pointeur int

  Enfin, obtenez la longueur de la tranche via *len

  Le fonctionnement de cap est similaire à len et ne sera pas décrit à nouveau ;

En bref : Grâce à la non-sécurité, nous pouvons convertir les adresses mémoire entre différents types de pointeurs, exploitant ainsi la mémoire de manière plus flexible

Cette expérience a également vérifié davantage la structure de stockage sous-jacente de ; la tranche ;

unsafe n'est pas nécessaire. Elle doit être utilisée avec parcimonie dans certaines conditions. Après tout, l'utilisation directe de la mémoire est risquée

[Recommandations associées :

Tutoriel vidéo Go

, Enseignement de la programmation]

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!