Explication détaillée de 11 points de connaissance sur les pointeurs en langage Go

Les pointeurs sont l'une des parties les plus importantes pour écrire un bon code. Dans cet article, nous explorerons ce que sont les pointeurs et comment les utiliser dans Go.

1. Qu'est-ce qu'un pointeur

Un pointeur est une variable qui stocke l'adresse vers laquelle elle pointe (c'est juste une variable qui stocke une valeur numérique). [Recommandations associées : Tutoriel vidéo Go]

Un pointeur d'un type spécifique ne peut pointer que vers ce type (le type de données pointé par le pointeur est immuable).

2. Syntaxe du pointeur GoLang

La syntaxe des pointeurs est très simple. Voici la syntaxe de déclaration du pointeur dans Go. La valeur zéro du pointeur

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

est nil.

3. Initialisation des pointeurs dans Go

les pointeurs de type sont initialisés à l'aide de & : & 对其进行初始化：

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
}

4. Go 指针取值

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

package main

import (
    "fmt"
)

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

5. GoLang 中指针的指针

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

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)
}

6. 指向接口的指针

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

package main

import (
    "fmt"
)

func main() {   
    var a interface{}
    b := &a
    fmt.Println(b)    // 0x40c138
    fmt.Println(*b)   // <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}
}

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

7. 指针作为函数参数

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

package main

import (
    "fmt"
)

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

func main() {   
    var a int = 42

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

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

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
}

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

package main

import (
    "fmt"
)

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

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

4. Aller à la valeur du pointeur La valeur du pointeur signifie obtenir la valeur dans l'adresse enregistrée par le pointeur. Voici un exemple d'utilisation de l'opérateur * pour effectuer des opérations sur la valeur du pointeur :

package main

import (
    "fmt"
)

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

    // 返回地址
    return &v
}

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

< /span >5. Le pointeur du pointeur dans GoLang

L'adresse du pointeur est une valeur numérique, et cette valeur numérique peut également être attribuée à d'autres variables. Nous pouvons donc créer des niveaux d’indirection. Ces niveaux d’indirection peuvent parfois créer une confusion inutile, alors utilisez-les avec prudence.

package main

import (
    "fmt"
)

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

6. Pointeur vers l'interface

Un pointeur peut pointer vers n'importe quoi, même vers une interface. . Lors de l'utilisation de l'interface vide, la valeur renvoyée est

nil

.

rrreee

Ce qui suit est un exemple d'utilisation d'une interface avec des pointeurs. rrreee

ici

"a"

est un struct

type Bird, qui est ensuite utilisé pour le type d'interface, comme vous pouvez le voir. C'est l'utilisation du polymorphisme. Go permet le polymorphisme

en utilisant des interfaces Vous pouvez donc voir qu'un pointeur vers une structure ou une interface est un outil essentiel dans. Aller.

7. Pointeurs comme paramètres de fonction

Le pointeur peut être dans le La fonction

est utilisée comme paramètre. Cela présente certains avantages par rapport à l'utilisation directe des valeurs. Utiliser des pointeurs comme arguments est un moyen très efficace de transmettre des objets volumineux aux fonctions. Son utilisation est donc une énorme optimisation.

rrreee

L'utilisation d'objets volumineux peut ralentir le temps d'exécution, voici un exemple de passage d'un pointeur vers une structure. C'est un moyen efficace de gérer des objets volumineux. 🎜🎜rrreee🎜🎜Soyez prudent lorsque vous déréférencez des structures. Si vous l'utilisez comme *structname.field1 alors il générera une erreur. 🎜La bonne🎜méthode est (*structname).field1. 🎜🎜L'utilisation de pointeurs à l'intérieur d'une fonction rend la valeur "🎜mutable🎜" sauf si son paramètre est 🎜const🎜, donc chaque fois que nous voulons modifier une valeur, nous devons utiliser un pointeur vers cette valeur comme paramètre de fonction, puis apporter les modifications nécessaires . 🎜🎜🎜8. La fonction "nouvelle" dans Go 🎜🎜🎜 La fonction 🎜nouvelle🎜 dans Go renvoie un pointeur vers un type. 🎜🎜rrreee🎜🎜🎜9. Renvoi de pointeurs à partir de fonctions 🎜🎜🎜 Tout type de pointeur peut être renvoyé à partir d'une fonction comme les autres valeurs. C'est vraiment simple. Nous ne renvoyons pas directement la valeur, mais l'adresse de la valeur. 🎜🎜rrreee🎜🎜🎜10. Pointeurs vers des fonctions 🎜🎜🎜Les pointeurs vers des fonctions fonctionnent implicitement dans Go. Cela signifie que nous n'avons pas besoin de le déclarer comme pointeur. 🎜🎜rrreee🎜🎜🎜11. Choses à retenir lors de l'utilisation de pointeurs dans Go🎜🎜🎜L'arithmétique des pointeurs n'est pas autorisée dans Go. Par conséquent, nous ne pouvons pas effectuer d’opérations telles que l’incrémentation ou la décrémentation unaire comme nous le pouvons en C/C++. 🎜Nous souhaiterions peut-être utiliser un pointeur vers un tableau, mais utiliser une tranche est une meilleure option. Les tranches sont beaucoup plus polyvalentes que les pointeurs vers des tableaux. Le code est très concis et facilite notre travail. Par conséquent, utilisez des tranches autant que possible. 🎜🎜Pour plus de connaissances sur la programmation, veuillez visiter : 🎜Vidéos de programmation🎜 ! ! 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!