Informationen zum Verständnis des Golang-Zeigers

Die folgende Kolumne führt Sie in das Verständnis des Golang-Zeigers aus der Kolumne Golang-Tutorial ein. Ich hoffe, dass es für Freunde hilfreich ist, die es brauchen!

0x00 Zeigeradresse und Zeigertyp

Eine Variable entspricht einem Speicherplatz, der den Wert des entsprechenden Typs der Variablen speichern kann zeigen Sie auf die Speicheradresse eines beliebigen Werts.

Erhalten Sie das Adresssymbol &. &
在指针类型前加上 * 号，可以获取指针所指向的内容，它是一个类型更改器，使用一个指针引用一个值称为间接引用。

prt := &v    // v 的类型为T

v 表示被取地址的变量，prt 接收 v 的地址，prt 的类型为 *T，称为 T 的指针类型。

0x01 从指针获取指针指向的值

使用 & 对变量进行取地址之后，获得这个变量的指针，可以对指针使用 * 号来获取这个指针指向的值，称为指针取值。

temp := "test content"
prt := &temp
fmt.Println(*prt)   // 打印 test content

变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：

对变量进行取地址（&）操作，可以获得这个变量的指针变量。
指针变量的值是指针地址。
对指针变量进行取值（*）操作，可以获得指针变量指向的原变量的值。

0x02 使用指针修改值

使用 * 对指针指向的值进行修改和操作

x, y := 1, 2
fmt.Println(x, y)  // 1 2
j, k := &x, &y
*j, *k = *k, *j
fmt.Println(x, y)  // 2 1

*Fügen Sie * vor dem Zeigertyp hinzu, um den Inhalt zu erhalten, auf den der Zeiger zeigt. Es handelt sich um einen Typwechsler, der einen Zeiger verwendet, um auf einen zu verweisen Der Wert wird als indirekte Referenz bezeichnet.

x, y := 1, 2
fmt.Println(x, y)  // 1 2
j, k := &x, &y
j, k = k, j
fmt.Println(x, y)    // 1 2
fmt.Printf("x : %p, y :  %p \n", &x, &y)  // x : 0xc00001a088, y :  0xc00001a090
fmt.Printf("j : %p, y :  %p \n", j, k)  //j : 0xc00001a090, y :  0xc00001a088

v stellt die Variable dar, deren Adresse prt die Adresse von v erhält > ist *T, ein Zeigertyp namens T.

0x01 Rufen Sie den Wert ab, auf den der Zeiger zeigt.

Nachdem Sie & verwendet haben, um die Adresse der Variablen abzurufen, können Sie den Zeiger dieser Variablen abrufen Das Symbol >* für den Zeiger wird als Zeigerwerterfassung bezeichnet.

var p = f()

func f() *int {
    v := 1
    return &v
}

Die Beziehungen und Eigenschaften von Variablen, Zeigeradressen, Zeigervariablen, Adressen und Werten sind wie folgt:

Führen Sie die Adressoperation (&) für eine Variable aus, um die Zeigervariable dieser Variablen zu erhalten.

Der Wert einer Zeigervariablen ist die Zeigeradresse.

Führen Sie die Wertoperation (*) für die Zeigervariable aus, um den Wert der ursprünglichen Variablen zu erhalten, auf die die Zeigervariable zeigt.

0x02 Verwenden Sie Zeiger, um Werte zu ändern

Verwenden Sie *, um den Wert zu ändern und zu bedienen, auf den der Zeiger zeigt.

	temp := new(int)
	*temp = 123
	fmt.Println(*temp)  // 123
	fmt.Println(temp)  //  0xaabb

* Die grundlegende Bedeutung Der Operator besteht darin, den Zeiger zu bedienen. Die Variable, auf die gezeigt wird. Wenn sich die Operation auf einen R-Wert bezieht, nimmt sie den Wert der Variablen an, auf die gezeigt wird; wenn die Operation auf einen L-Wert angewendet wird, setzt sie den Wert auf die Variable, auf die gezeigt wird.

🎜Wenn Sie nur referenzierte Zeiger austauschen, sind die referenzierten Variablen, Werte und Adressen nicht betroffen, sondern nur die Anwendungszeiger. 🎜

package main

import (
    "flag"
    "fmt"
    "strings"
)

var n = flag.Bool("n", true, "print test")
var sep = flag.String("s", " ", "separator")
var test = flag.String("test", " ", "测试")

func main() {
    flag.Parse()
    fmt.Println(strings.Join(flag.Args(), *sep))
    if *n {
        fmt.Println(*test)
    }
}

🎜Die Werte und Adressen von x und y sind nicht betroffen. Nachdem die Zeiger j und k ausgetauscht wurden, werden die Werte von j und k ausgetauscht. 🎜🎜🎜0x03 Lokale Variablen in der Funktion zurückgeben 🎜🎜🎜🎜In der Go-Sprache ist es auch sicher, die Adresse lokaler Variablen in der Funktion zurückzugeben. Der folgende Code erstellt beispielsweise eine lokale Variable v, wenn die f-Funktion aufgerufen wird. Nachdem die lokale Variablenadresse zurückgegeben wurde, ist sie immer noch gültig, da der Zeiger p immer noch auf diese Variable verweist. 🎜🎜

$ go run main.go --help
Usage of /var/exe/main:
  -n	print test
  -s string
    	separator (default " ")
  -test string
    	测试 (default " ")
exit status 2
$ go run main.go -s "+"  --test 测试文本 a bc def 123
a+bc+def+123
$ go run main.go -s "+" -n --test 测试文本 a bc def 123
a+bc+def+123
测试文本

🎜🎜0x04 Verwenden Sie new(), um den Zeiger zu erstellen Die Schlüsseltechnologie zum Implementieren des Flag-Pakets in der Standardbibliothek. Es wird verwendet, um das Parsen von Befehlszeilen-Flags zu implementieren. 🎜Beispiel: 🎜rrreee🎜Run🎜rrreee

Das obige ist der detaillierte Inhalt vonInformationen zum Verständnis des Golang-Zeigers. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!