Golang -Hinweise

Ein Zeiger in der Programmierung bezieht sich auf die Variable, mit der die Speicheradresse einer anderen Variablen im System gespeichert wird. Die Speicheradresse der Variablen wird im hexadezimalen Format ab 0x ausgedrückt.

Zeiger sind nützlich, da sie es uns ermöglichen, den Speicher einer Adresse zu speichern, bei der die von einer Variablen gehaltenen Daten gespeichert sind. Verwenden von Zeigern bestimmen wir den Wert, der von der Variablen an dieser Speicheradresse gespeichert ist.

In diesem anfängerfreundlichen Artikel werden wir diskutieren, wie Sie mit Zeigern in der Go -Programmiersprache beginnen können.

Golang deklarieren Variable

Wir deklarieren einem Zeiger genauso wie wir eine normale Variable deklarieren. Wir verwenden jedoch den Dereferenzbetreiber, um zu zeigen, dass die Variable einen Zeiger enthält.

Bevor wir eine Variable deklarieren, müssen wir zwei Operatoren vertraut sein:

1. * - Das Sternchen in der Zeigerdeklaration wird als Derferenzbetreiber bezeichnet. Es wird verwendet, um einen Zeigerwert zu deklarieren und auf den Wert zuzugreifen, der in einer bestimmten Speicheradresse gespeichert ist.
2. & - Im Zeiger wird der Adressoperator verwendet, um auf die Speicheradresse einer Variablen zuzugreifen. Es kann auch die Adresse der Variablen zurückgeben.

Die folgende Syntax zeigt, wie Sie eine Zeigervariable deklarieren:

var pointer_name *data_type

Beispielsweise deklariert der folgende Code eine Zeigervariable „PTR“, die die Adresse von Int -Typen enthält.

var ptr *int

Golang Zeiger initialisieren

Wir können einen Zeiger initialisieren, indem wir die Speicheradresse einer Variablen mit dem oben gezeigten Adressoperator zuweisen.

Ein Beispiel ist wie gezeigt:

Paket Main
importieren "fmt"
func main ()
// Variable deklarieren
x: = 100
// Zeiger deklarieren und initialisieren
var ptr *int = & x
// Adresse drucken
fmt.Println (ptr)

Im obigen Beispiel beginnen wir zunächst eine Variable, die einen Ganzzahlwert hält. Wir erstellen dann einen Zeiger, der die Speicheradresse der Variablen hält.

Sobald wir die Adresse drucken, sollten wir wie gezeigt eine Beispielausgabe erhalten:

$ go run zeiger.gehen
0xc000018098

Wir können auch eine Variable deklarieren und den Wert später im Code festlegen. Ein Beispiel ist wie gezeigt:

Paket Main
importieren "fmt"
func main ()
// Variable deklarieren
x: = 100
// deklarieren
var ptr *int
ptr = & x
// Adresse drucken
fmt.Println (ptr)

Hier deklarieren wir den Zeiger und setzen später seinen Wert mit dem Adressoperator.

Golang Nil Zeiger

Wenn Sie einen Zeiger deklarieren und keinen Wert zuweisen, enthält der Zeiger einen Nullwert. Zum Beispiel:

Paket Main
importieren "fmt"
func main ()
var ptr *int
fmt.Println (ptr)

Der obige Code gibt Nil zurück.

Zeigertyp

In unserem Beispiel haben wir den Typ des Zeigers deklariert. Dies bedeutet.

Wenn Sie versuchen, die Adresse eines anderen Typs zu speichern, gibt der Compiler einen Fehler zurück, wie im folgenden Beispiel gezeigt:

Paket Main
importieren "fmt"
func main ()
// Variable deklarieren
STR: = "Hallo"
var ptr *int
ptr = & str
// Adresse drucken
fmt.Println (ptr)

Im obigen Beispiel deklarieren wir eine Variable mit Typ int int. Wir weisen jedoch eine Adresse eines String -Typs zu.

Der Compiler gibt einen Fehler zurück als:

.\Zeiger.GO: 11: 6: Kann nicht verwenden & str (Typ *String) als Typ *int in der Zuordnung

Um dies zu vermeiden, können Sie die Zeiger -Literalmethode der Deklaration verwenden. Zum Beispiel können wir:

Paket Main
importieren "fmt"
func main ()
STR: = "Hallo"
ptr: = & str
fmt.Println (ptr)

Mit dem obigen Beispiel ermöglicht es dem Compiler, den Adressart zu bestimmen, der im angegebenen Zeiger gehalten werden soll.

Golangzeiger Dereference

Um auf den an einer bestimmten Adresse gespeicherten Wert zugreifen zu können, können wir den Derercencing -Operator verwenden. Ein Beispielcode ist wie gezeigt:

Paket Main
importieren "fmt"
func main ()
x: = 100
ptr: = & x
fmt.Println ("x:", x)
fmt.Println ("Adresse:", ptr)
fmt.Println ("Wert an Adresse:", *ptr)

Der obige Code verwendet den Dereferenzbetreiber, um den Wert zu erhalten, der unter der Adresse des Zeigers „PTR“ gespeichert wird,

Die resultierende Ausgabe lautet wie:

X: 100
Adresse: 0xc000018098
Wert bei Adresse: 100

Abschluss

Dieser Leitfaden führt Sie durch die Grundlagen der Arbeit mit Zeigern in Go. Verwenden von Zeigern können Sie auf die Speicheradresse einer Variablen zugreifen und speichern. Sie können den Zeiger auch verwenden, um auf die in einer bestimmten Speicheradresse gespeicherte Variable zugreifen zu können.

Danke fürs Lesen!