Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?

Dieser Artikel wird von der Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?-SpracheTutorial-Kolumne eingeführt, um 11 Wissenspunkte über Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden? Pointer vorzustellen. Ich hoffe, dass er Freunden in Not hilfreich sein wird!

                                                                                                                                                                                                                 In diesem Artikel werden wir untersuchen, was Zeiger sind und wie man sie in Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden? verwendet.

1. Was ist ein Zeiger?

Ein Zeiger ist eine Variable, die die Adresse speichert, auf die sie zeigt. Ein Zeiger eines bestimmten Typs kann nur auf diesen Typ zeigen (Datentypen sind unveränderlich).

2. Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?Lang-Zeigersyntax

Die Syntax von Zeigern ist sehr einfach. Im Folgenden finden Sie die Syntax für die Zeigerdeklaration in Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?. Der Nullwert des

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

-Zeigers ist nil

.

3. Initialisierung von Zeigern im Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?-Typ

Zeiger werden mit & initialisiert:

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

4. Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?-Zeigerwert

& 对其进行初始化：

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

4. Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden? 指针取值

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

package mainimport (
    "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. Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?Lang 中指针的指针

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

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

6. 指向接口的指针

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

package mainimport (
    "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 mainimport (
    "fmt")//声明指针参数func f(a *int) {
    fmt.Println(*a)}func main() {   
    var a int = 42

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

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

7. 指针作为函数参数

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

package mainimport (
    "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 mainimport (
    "fmt")func main() {   
    ptri := new(int)
    *ptri = 67

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

取消引用结构时要小心。如果您使用它像*structname.field1那么它会抛出错误。 正确的方法是(*structname).field1Zeigerwert bedeutet, den Zeigerwert innerhalb des gespeicherten Wertes zu erhalten Adresse. Das Folgende ist ein Beispiel für die Verwendung des Operators * zum Ausführen einer Zeigerwertoperation:

package mainimport (
    "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 Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?Lang

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

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

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

nil

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

rrreee

Hier

"a"

ist eine Struktur vom Typ Bird, die dann, wie Sie sehen können, für den Schnittstellentyp verwendet wird. Dies ist die Verwendung von Polymorphismus. Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden? ermöglicht Polymorphismus mithilfe von Schnittstellen. Sie sehen also, dass Zeiger auf Strukturen oder Schnittstellen ein wesentliches Werkzeug in Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden? sind.

7. Zeiger als Funktionsparameter

Zeiger können als Parameter in Funktionen verwendet werden. 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. rrreeeDie 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 konstant. 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 Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden? 🎜🎜 Die 🎜new🎜-Funktion in Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden? 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 Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?. Das bedeutet, dass wir es nicht als Zeiger deklarieren müssen. 🎜rrreee🎜🎜🎜11. Dinge, die Sie bei der Verwendung von Zeigern in Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden? beachten sollten🎜🎜Zeigerarithmetik ist in Was ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden? 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. 🎜🎜🎜Originaladresse: https://golangdocs.com/pointers-in-golang🎜🎜Übersetzungsadresse: https://learnku.com/go/t/60880🎜🎜

Das obige ist der detaillierte Inhalt vonWas ist ein Go-Pointer? Welche Wissenspunkte müssen beherrscht werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!