Detaillierte Erläuterung von 11 Wissenspunkten zu Zeigern in der Go-Sprache

Zeiger sind einer der wichtigsten Bestandteile beim Schreiben von gutem Code. In diesem Artikel werden wir untersuchen, was Zeiger sind und wie man sie in Go verwendet.

1. Was ist ein Zeiger? Ein Zeiger ist eine Variable

, die die Adresse speichert, auf die er zeigt (der Schwerpunkt liegt darauf, dass es sich nur um eine Variable handelt, die einen numerischen Wert speichert). [Verwandte Empfehlungen:

Go-Video-Tutorial]Ein Zeiger eines bestimmten Typs kann nur auf diesen Typ zeigen (der Datentyp, auf den der Zeiger zeigt, ist unveränderlich).

2. GoLang-Zeigersyntax

Die Syntax von Zeigern ist sehr einfach. Im Folgenden finden Sie die Syntax für die Zeigerdeklaration in Go. Der Nullwert des

var ptr *type
var ptrint *int     // 指向 int 的指针

-Zeigers ist

nil

.

3. Initialisierung von Zeigern in Go

Typzeiger werden mit & initialisiert:

package main

import (
    "fmt"
)

func main() {
    var q int = 42
    var p *int     // declare the pointer
    p = &q         // initialize the pointer
    fmt.Println(p)  // 0x40e020
}

& 对其进行初始化：

package main

import (
    "fmt"
)

func main() {
    var q int = 42
    var p *int
    p = &q
    fmt.Println(p)  // 0x40e020
    fmt.Println(*p) // 42
}

4. Go 指针取值

指针取值意味着获取指针保存的地址内的值。下面是使用 * 运算符执行指针取值操作的示例：

package main

import (
    "fmt"
)

func main() {   
    i := 64
    j := &i  // j 是 int 类型的指针
    k := &j  // k 是存放指针地址的指针，也是 int 类型

    fmt.Println(i)  // 64

    fmt.Println(j)  // 0x40e020 

    fmt.Println(*j) // 64 (value inside that address)

    fmt.Println(k)  // 0x40c138

    fmt.Println(*k) // 0x40e020 (address of j)
}

5. GoLang 中指针的指针

指针的地址为一个数值，此数值也可以被赋值给其他变量。因此，我们可以创建间接级别。这些间接级别有时会产生不必要的混淆，所以请谨慎使用。

package main

import (
    "fmt"
)

func main() {   
    var a interface{}
    b := &a
    fmt.Println(b)    // 0x40c138
    fmt.Println(*b)   // <nil>
}

6. 指向接口的指针

指针可以指向任何东西，甚至可以指向接口。当使用空接口时，返回的值为 nil。

package main

import (
    "fmt"
)

// 定义接口
type Bird interface{
    fly()
}

type B struct{
    name string
}

// 实现它
func (b B)fly() {
    fmt.Println("Flying...")
}

func main() {   
    var a Bird = B{"Peacock"}
    b := &a
    fmt.Println(b)    // 0x40c138
    fmt.Println(*b)   // {Peacock}
}

下面是一个使用带有指针接口的例子。

package main

import (
    "fmt"
)

//声明指针参数
func f(a *int) {
    fmt.Println(*a)
}

func main() {   
    var a int = 42

    // 传递地址
    f(&a) // 42
}

这里 “a” 是一个 struct 类型的 Bird，然后用于接口类型，如您所见。这就是多态的使用。Go 允许使用 接口来实现多态. 因此，您可以看到指向结构或接口的指针是 Go 中必不可少的工具。

7. 指针作为函数参数

指针可以在 函数 中作为参数使用。与直接使用值相比，它有一些优势。使用指针作为参数是将大对象传递给函数的一种非常有效的方式。因此，使用它是一个巨大的优化。

package main

import (
    "fmt"
)

type Human struct {
    name string
    age int
    place string
}

func f(h *Human) {
    fmt.Println("The user", (*h).name, "is", (*h).age, "years old and he is from", (*h).place)
}

func main() {   
    john := Human{"John", 36, "Las Vegas"}

    f(&john) // The user John is 36 years old and he is from Las Vegas
}

使用大型对象可以减缓执行时间，这是将指针传递给结构体的示例。这是处理大对象的有效方法。

package main

import (
    "fmt"
)

func main() {   
    ptri := new(int)
    *ptri = 67

    fmt.Println(ptri)  // 0x40e020
    fmt.Println(*ptri) // 67
}

取消引用结构时要小心。如果您使用它像 *structname.field1 那么它会抛出错误。 正确的方法是 (*structname).field14. Go-Zeigerwert

Zeigerwert bedeutet, den Wert in der vom Zeiger gespeicherten Adresse abzurufen. Das Folgende ist ein Beispiel für die Verwendung des *-Operators zum Ausführen von Zeigerwertoperationen:

package main

import (
    "fmt"
)

func p() *int {  // 将返回类型指定为指针
    v := 101

    // 返回地址
    return &v
}

func main() {   
    n := p()
    fmt.Println(n)  // 0x40e020
    fmt.Println(*n) // 101
}

5. Der Zeiger des Zeigers in GoLang

Die Adresse des Zeigers ist ein numerischer Wert, und dieser numerische Wert kann auch anderen Variablen zugewiesen werden. Daher können wir Indirektionsebenen erstellen. Diese Ebenen der Indirektion können manchmal unnötige Verwirrung stiften, also verwenden Sie sie mit Vorsicht.

package main

import (
    "fmt"
)

func main() {       
    f := func() {
        fmt.Println("a function")   
    }
    pf := f
    pf() // 一个函数
}

6. Zeiger auf Schnittstellen

Zeiger können auf alles verweisen, sogar auf Schnittstellen. Bei Verwendung der leeren Schnittstelle ist der zurückgegebene Wert

nil.

rrreee

Das Folgende ist ein Beispiel für die Verwendung einer Schnittstelle mit Zeigern.

rrreee

hier"a"

ist ein struct

Typ Bird, der dann für verwendet wird der Schnittstellentyp, wie Sie sehen können. Dies ist die Verwendung von Polymorphismus. Go erlaubt Polymorphismus

unter Verwendung von Schnittstellen. Sie können also sehen, dass ein Zeiger auf eine Struktur oder Schnittstelle ein wesentliches Werkzeug ist Gehen.

7. Zeiger als Funktionsparameter

Der Zeiger kann im Funktion

wird als Parameter verwendet. Es hat einige Vorteile gegenüber der direkten Verwendung von Werten. Die Verwendung von Zeigern als Argumente ist eine sehr effiziente Möglichkeit, große Objekte an Funktionen zu übergeben. Die Verwendung ist also eine enorme Optimierung.

rrreee

Die Verwendung großer Objekte kann die Ausführungszeit verlangsamen. Hier ist ein Beispiel für die Übergabe eines Zeigers an eine Struktur. Dies ist eine effiziente Möglichkeit, große Objekte zu handhaben. rrreee

🎜Seien Sie vorsichtig beim Dereferenzieren von Strukturen. Wenn Sie es wie *structname.field1 verwenden, wird ein Fehler ausgegeben. 🎜Die richtige🎜Methode ist (*structname).field1. 🎜🎜Die Verwendung von Zeigern innerhalb einer Funktion macht den Wert „🎜veränderlich🎜“, es sei denn, sein Parameter ist 🎜const🎜. Wenn wir also einen Wert ändern möchten, sollten wir einen Zeiger auf diesen Wert als Funktionsparameter verwenden und dann die erforderlichen Änderungen vornehmen . 🎜🎜🎜8. Die „neue“ Funktion in Go 🎜🎜🎜 Die 🎜new🎜-Funktion in Go gibt einen Zeiger auf einen Typ zurück. 🎜🎜rrreee🎜🎜🎜9. Zeiger von Funktionen zurückgeben 🎜🎜🎜 Jeder Zeigertyp kann von einer Funktion zurückgegeben werden, genau wie andere Werte. Es ist wirklich einfach. Wir geben nicht direkt den Wert zurück, sondern die Adresse des Werts. 🎜🎜rrreee🎜🎜🎜10. Zeiger auf Funktionen 🎜🎜🎜Zeiger auf Funktionen funktionieren implizit in Go. Das bedeutet, dass wir es nicht als Zeiger deklarieren müssen. 🎜🎜rrreee🎜🎜🎜11. Dinge, die Sie bei der Verwendung von Zeigern in Go beachten sollten🎜🎜🎜Zeigerarithmetik ist in Go nicht zulässig. Daher können wir Operationen wie unäres Inkrementieren oder Dekrementieren nicht wie in C/C++ ausführen. 🎜Vielleicht möchten wir einen Zeiger auf ein Array verwenden, aber die Verwendung eines Slice ist eine bessere Option. Slices sind viel vielseitiger als Zeiger auf Arrays. Der Code ist sehr prägnant und erleichtert uns die Arbeit. Verwenden Sie daher nach Möglichkeit Scheiben. 🎜🎜Weitere Kenntnisse zum Thema Programmierung finden Sie unter: 🎜Programmiervideos🎜! ! 🎜

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von 11 Wissenspunkten zu Zeigern in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!