So implementieren Sie die Zeigerkonvertierung in Golang

In Golang können Sie das unsichere Paket verwenden, um die Zeigerkonvertierung zu implementieren und Speicheradressen zwischen verschiedenen Zeigertypen zu konvertieren und so den Speicher flexibler zu betreiben. Beispielsweise kann die Pointer()-Funktion im unsicheren Paket die Adresse einer beliebigen Variablen in einen Zeigertyp umwandeln oder den Zeigertyp in einen beliebigen Zeigertyp umwandeln. Der Zeigertyp ist ein Zwischentyp für die Konvertierung zwischen verschiedenen Zeigertypen.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

In Golang können Sie das unsichere Paket verwenden, um die Zeigerkonvertierung zu implementieren.

golangs Zeigerkonvertierung

Golang stellt das unsichere Paket bereit, das es uns ermöglicht, den Speicher direkt an der angegebenen Speicheradresse zu betreiben.

Unter dem unsicheren Paket gibt es eine Definition des Typs Pointer *ArbitraryType (Zeiger eines beliebigen Typs), die die Typbeschränkungen von GO Type ArbitraryType int umgehen kann. Jeder Typ von Zeigerwert kann in einen Zeiger konvertiert werden.

• Pointer kann in jede Art von Zeigerwert konvertiert werden.

• uintptr kann in Zeiger konvertiert werden.

• Zeiger kann in uintptr konvertiert werden.

• Durch die Funktion unsafe.Pointer() können wir die Speicheradressendarstellung der Variablen erhalten, die im Wesentlichen eine Ganzzahl ist. Die Adresse einer beliebigen Variablen kann in einen Zeigertyp konvertiert werden, oder der Zeigertyp kann in einen beliebigen Zeigertyp konvertiert werden. Es handelt sich um einen Zwischentyp für die Konvertierung zwischen verschiedenen Zeigertypen.

Der Zeiger unterstützt jedoch keine Operationen. Wenn Sie Additions- und Subtraktionsoperationen für die Speicheradresse ausführen möchten, müssen Sie diese in den Typ uintptr konvertieren.

Nachfolgend versuchen wir, die Slice-Adresse zu lesen und ihren Inhalt durch Speicheroperationen zu durchlaufen:

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

Im obigen Code:

unsafe.Pointer(&s) ruft die Erinnerung an die erste Position der zugrunde liegenden Darstellung ab von Slice s Die Adresse, also die Adresse des zugrunde liegenden Arrays, wird über (**[10]int)(unsafe.Pointer(&s)) in einen Zeiger vom Typ **[10]int konvertiert und in * wiederhergestellt *addrss bis **addrss Array;

• unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(8)) Erhalten Sie durch Adressoperation die Speicheradresse der Länge,

  und dann durch (*int )(unsafe.Pointer(uintptr( unsafe.Pointer(&s)) + uintptr(8))) Konvertieren Sie den Längenspeicher in einen int-Zeiger

Erhalten Sie schließlich die Slice-Länge durch *len;

• Die Operation von cap ähnelt len ​​und wird nicht noch einmal beschrieben;

  Kurz gesagt:

Durch unsicher können wir Speicheradressen zwischen verschiedenen Zeigertypen konvertieren und so den Speicher flexibler betreiben; Dieses Experiment hat auch die zugrunde liegende Speicherstruktur weiter überprüft das Slice; unsicher ist nicht notwendig. Unter bestimmten Bedingungen sollte es sparsam eingesetzt werden. Der direkte Betrieb des Speichers ist schließlich riskant

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Zeigerkonvertierung in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!