Go SprachZeiger

A pointer in the Go programming language is a variable used to store the memory address of another variable. Pointers in Golang are also called special variables.VariableUsed to store some data at a specific memory address in the system. Memory addresses are always found in hexadecimal format (starting with 0x, such as 0xFFAAF, etc.).

What is the role of pointers?
To understand this pointer, we must first understand the concept of a variable. A variable is a name given to an actual data storage location. To access the stored data, we need the address of the specific storage location. It is a costly task to manually remember all memory addresses (in hexadecimal format), which is why we use variables to store data and can access variables only by using their names.
Golang also allows the use of literal expressions to save hexadecimal numbers into variables, that is, from0xThe starting number is a hexadecimal number.

Beispiel:In the following program, we will store hexadecimal numbers in variables. But you can see that the type of the value isintand save as decimal, or in other wordsintThe decimal value of the type is being stored. However, the main point of this example is that we are storing hexadecimal values (considered as memory addresses), but it is not a pointer because it does not point to any other memory location of any other variable. It is just a user-defined variable. Therefore, pointers are needed.

//Store hexadecimal value
package main
import "fmt"
func main() {
　　　　//Store hexadecimal
　　　　//Value in the variable
　　　　x := 0xFF
　　　　y := 0x9C
　　　　//　Display value
　　　　fmt.Printf("The type of variable x is %T\n", x)
　　　　fmt.Printf("x's hexadecimal value is %X\n", x)
　　　　fmt.Printf("x's decimal value is %v\n", x)
　　　　fmt.Printf("The type of variable y is %T\n", y)
　　　　fmt.Printf("y's hexadecimal value is %X\n", y)
　　　　fmt.Printf("y's decimal value is %v\n", y)
}

Ausgabe:

Der Typ der Variable x ist int
Der Hexadezimalwert von x ist FF
Der Dezimalwert von x ist　255
Der Typ der Variable y ist int
Der Hexadezimalwert von y ist　9C
Der Dezimalwert von y ist　156

Ein Zeiger ist eine spezielle Variable, die nicht nur zur Speicherung der Speicheradressen anderer Variablen verwendet wird, sondern auch auf den Speicherort verweist und Methoden bietet, um auf den Wert, der an diesem Speicherort gespeichert ist, zuzugreifen. Er wird normalerweise als spezieller Variablentyp bezeichnet, da er fast wie eine Variable deklariert wird, aber mit*（Dereferenzierungsoperator）.

Zeigerdeklaration und -initialisierung

Bevor wir beginnen, werden wir in den Zeigern zwei wichtige Operatoren verwenden, nämlich

*Operator Der auch als Dereferenzierungsoperator bezeichnet wird, der verwendet wird, um Zeigervariablen zu deklarieren und auf den Wert, der in der Adresse gespeichert ist, zuzugreifen.

＆-Operator Der &-Operator, der verwendet wird, um die Adresse einer Variable zurückzugeben oder den Zeiger auf die Adresse der Variable zuzugreifen.

Deklarieren Sie einen Zeiger:

var pointer_name　*Data_Type

Beispiel:Hier ist ein Zeiger auf den Datentyp String, der nurZeichenketteDie Speicheradresse der Variable.

var s　*string

Initialisierung des Zeigers:Dafür müssen Sie den Adressoperator verwenden, um die Speicheradresse einer anderen Variable zu initialisieren, wie im folgenden Beispiel gezeigt:

//Normale Variablendeklaration
var a =　45
//Verwenden Sie den initialisierten Zeiger s
//Die Speicheradresse der Variable a
var s　*int = &a

//　Ein Golang-Programm zur Demonstration der Deklaration
//und die Initialisierung des Zeigers
package main
import "fmt"
func main() {
　　　　//Definieren Sie eine normale Variable
　　　　var x int =　5748
　　　　//Zeigerdeklaration
　　　　var p　*int
　　　　//Initialisieren Sie den Zeiger
　　　　p = &x
　　　　//Anzeigeergebnis
　　　　fmt.Println("Der Wert, der in x gespeichert ist = ", x)
　　　　fmt.Println("Die Speicheradresse von x = ", &x)
　　　　fmt.Println("Der Wert, der in der Variable p gespeichert ist = ", p)
}

Ausgabe:

Der Wert, der in x gespeichert ist =　　5748
Die Speicheradresse von x = 0xc000066090
Der Wert, der in der Variable p gespeichert ist = 0xc000066090

Wichtiges Thema:

• Der Standardwert oder der Nullwert eines Zeigers ist immer nil. Oder Sie können sagen, dass ein nicht initialisierter Zeiger immer den nil-Wert hat.

  Beispiel

  //Der nil-Wert eines Zeigers
  package main
  import "fmt"
  func main() {
  　　　　//Definieren Sie einen Zeiger
  　　　　var s　*int
  　　　　//　Anzeigeergebnis
  　　　　fmt.Println("s = ", s)
  }

  Ausgabe:

  s = <nil>

• Die Deklaration und Initialisierung des Zeigers können in einer Zeile abgeschlossen werden.

  var s　*int = &a

• Wenn Sie sowohl den Datentyp als auch die Zeigerdeklaration angeben möchten, kann der Zeiger die Speicheradresse der angegebenen Datentypvariablen verarbeiten. Zum Beispiel, wenn Sie einen Zeiger auf den Datentyp String verwenden, dann ist die Adresse der Variablen, die dem Zeiger zur Verfügung gestellt wird, nur die Adresse der Variablen des Datentyps String und nicht die Adresse anderer Datentypen.

• Um diese Probleme zu überwinden, kanndas Schlüsselwort varDer Konzept der Typinferenz. Es ist während der Deklaration nicht erforderlich, den Datentyp zu spezifizieren. Der Typ von Zeigervariablen kann ebenfalls wie eine normale Variable durch den Compiler bestimmt werden. In diesem Fall werden wir nicht verwenden*Operator. Wenn wir die Adresse einer anderen Variable verwenden, um eine Variable zu initialisieren, wird sie intern vom Compiler bestimmt.

  Beispiel

  //　Ein Golang-Programm zur Demonstration
  //mit Typ-Interpretation verwenden
  //Zeiger-Variable
  package main
  import "fmt"
  func main() {
  　　　　//Verwendung des var-Schlüsselworts
  　　　　//Wir haben nicht definiert
  　　　　//Jeglicher Variable-Typ
  　　　　var y =　458
  　　　　//Verwendung des Zeiger-Variable
  　　　　//　Das var-Schlüsselwort, ohne Typ zu spezifizieren
  　　　　//Typ
  　　　　var p = &y
  　　　　fmt.Println("Der Wert in y beträgt =", y)
  　　　　
  　　　　fmt.Println("Der Wert im Zeiger-Variable p beträgt =", p)
  }

  Ausgabe:

  Der Wert in y beträgt =　　458
  Die Adresse von y beträgt = 0xc0000120a8
  Der Wert im Zeiger-Variable p beträgt = 0xc0000120a8

• Sie können auchKurzschreibweise（:=）Syntax, um Zeiger-Variable zu deklarieren und zu initialisieren. Wenn wir＆（Adresse）Operator gibt die Adresse des Variables an, dann bestimmt der Compiler intern, dass der Variable ein Zeiger-Variable ist.

  Beispiel

  //　Ein Golang-Programm zur Demonstration
  //mit der Kurzschreibweise verwenden
  //Zeiger-Variable
  package main
  import "fmt"
  func main() {
  　　　　//Verwendung des :=-Operators für die Deklaration
  　　　　//und initialisiere die Variable
  　　　　y :=　458
  　　　　//Verwendung eines Zeiger-Variable
  　　　　//durch := für ihre Zuweisung
  　　　　//Adresse der Variable y
  　　　　p := &y
  　　　　fmt.Println("Der Wert in y beträgt =", y)
  　　　　
  　　　　fmt.Println("Der Wert im Zeiger-Variable p beträgt =", p)
  }

  Ausgabe:

  Der Wert in y beträgt =　　458
  Die Adresse von y beträgt = 0xc000066090
  Der Wert im Zeiger-Variable p beträgt = 0xc000066090

Zeiger-Referenzlösung

Wohl bekannt ist*Operator wird auch als Entfernen der Referenz-Operator bezeichnet. Er wird nicht nur für die Deklaration von Zeiger-Variable verwendet, sondern auch zur Zugriff auf den Wert in der Variable, auf die der Zeiger zeigt, und wird normalerweise alsIndirekte oder Referenzlösung。*Operator wird auch als Wert am Adresse bezeichnet。Lassen Sie uns ein Beispiel nennen, um dieses Konzept besser zu verstehen:

//　Beispiel eines Golang-Programms
//Konzept der Zeiger-Referenzlösung
package main
import "fmt"
func main() {
　　　　//Verwendung des var-Schlüsselworts
　　　　//Wir haben nicht definiert
　　　　//Jeglicher Variable-Typ
　　　　var y =　458
　　　　//Verwendung des Zeiger-Variable
　　　　//　Das var-Schlüsselwort, ohne Typ zu spezifizieren
　　　　//Typ
　　　　var p = &y
　　　　fmt.Println("Der Wert in y beträgt =", y)
　　　　
　　　　fmt.Println("Der Wert im Zeiger-Variable p beträgt =", p)
　　　　//Das ist das Entfernen der Referenz des Zeigers
　　　　//vor dem Zeiger verwenden*Operator
　　　　//Variable um den gespeicherten Wert zu erreichen
　　　　//Zeiger auf die Variable
　　　　fmt.Println("Der Wert in y beträgt(",*p) = "　*p)
}

Ausgabe:

Der Wert in y beträgt =　　458
Die Adresse von y beträgt = 0xc0000120a8
Der Wert im Zeiger-Variable p beträgt = 0xc0000120a8
Der Wert in y beträgt(*p) =　　458

Sie können auch den Wert des Zeigers oder den Speicherort ändern, anstatt einem Variable neuen Wert zuzuweisen.

package main
import "fmt"
func main() {
　　　　//Verwendung des var-Schlüsselworts
　　　　//Wir haben nicht definiert
　　　　//Der Typ der Variable ist nicht spezifiziert
　　　　var y =　458
　　　　//Verwendung des Zeiger-Variable
　　　　//　Das var-Schlüsselwort, ohne Typ zu spezifizieren
　　　　var p = &y
　　　　fmt.Println("Ungewandelte Werte in y betragen =", y)
　　　　fmt.Println("Die Adresse von y beträgt =", &y)
　　　　fmt.Println("Der Wert im Zeiger-Variable p beträgt =", p)
　　　　//Das ist das Entfernen der Referenz des Zeigers
　　　　//vor dem Zeiger verwenden*Operator
　　　　//Variable um den gespeicherten Wert zu erreichen
　　　　//Zeiger auf die Variable
　　　　fmt.Println("Ungewandelte Werte werden in y(*Der Wert in p) beträgt "　*p)
　　　　//Veränderung des Wertes von y durch Zuweisung
　　　　//Neuer Zeiger-Wert
　　　　*p =　500
　　　　fmt.Println("Geänderte Werte werden in y(*Der Wert in p) beträgt "，y)
}

Ausgabe:

Ungewandelte Werte in y betragen =　　458
Die Adresse von y beträgt = 0xc0000120a8
Der Wert im Zeiger-Variable p beträgt = 0xc0000120a8
Ungewandelte Werte werden in y(*p)Wert=　　458
Geänderte Werte werden in y(*p)Wert=　　500