Qu'est-ce qu'un pointeur Go ? Quels sont les points de connaissances à maîtriser ?

Cet article est introduit par la colonne tutoriel go language pour présenter 11 points de connaissances sur Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? Pointer. J'espère qu'il sera utile aux amis dans le besoin !

                                                                                                                                                                                                                 Les pointeurs sont l'une des parties les plus importantes de l'écriture d'un bon code. Dans cet article, nous explorerons ce que sont les pointeurs et comment les utiliser dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?.

1. Qu'est-ce qu'un pointeur ?

Un pointeur est une variable qui stocke l'adresse vers laquelle il pointe. Un pointeur d'un type spécifique ne peut pointer que vers ce type (les types de données sont immuables).

2. Syntaxe du pointeur Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?Lang

La syntaxe des pointeurs est très simple. Voici la syntaxe de déclaration du pointeur dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?. La valeur zéro du pointeur

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

est nil

.

3. Initialisation des pointeurs dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?

les pointeurs de type sont initialisés à l'aide de & :

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. adresse. Voici un exemple d'utilisation de l'opérateur * pour effectuer une opération sur la valeur du pointeur :

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

& 对其进行初始化：

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

4. Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? 指针取值

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

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

5. Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?Lang 中指针的指针

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

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

6. 指向接口的指针

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

package mainimport (
    "fmt")//声明指针参数func f(a *int) {
    fmt.Println(*a)}func main() {   
    var a int = 42

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

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

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}

这里 “a” 是一个 struct 类型的 Bird，然后用于接口类型，如您所见。这就是多态的使用。Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? 允许使用 接口来实现多态. 因此，您可以看到指向结构或接口的指针是 Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? 中必不可少的工具。

7. 指针作为函数参数

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

package mainimport (
    "fmt")func main() {   
    ptri := new(int)
    *ptri = 67

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

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

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

    // 返回地址
    return &v}func main() {   
    n := p()
    fmt.Println(n)  // 0x40e020
    fmt.Println(*n) // 101}

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

5 Le pointeur du pointeur dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?LangL'adresse du pointeur est une valeur numérique, et cette valeur peut également être attribuée à d'autres valeurs 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 mainimport (
    "fmt")func main() {       
    f := func() {
        fmt.Println("a function")   
    }
    pf := f    pf() // 一个函数}

6. Pointeurs vers des interfaces

Les pointeurs peuvent pointer vers n'importe quoi, même vers des interfaces. 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. rrreeeIci

"a"

est un type de structure Bird qui est ensuite utilisé pour le type d'interface comme vous pouvez le voir. C'est l'utilisation du polymorphisme. Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? permet le polymorphisme à l'aide d'interfaces. Vous pouvez donc voir que les pointeurs vers des structures ou des interfaces sont un outil essentiel dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?.

7. Pointeurs comme paramètres de fonction

Les pointeurs peuvent être utilisés comme paramètres dans les fonctions. 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. rrreeeSoyez 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

" à moins que son paramètre ne soit const, donc chaque fois que nous voulons modifier une valeur, nous devons utiliser un pointeur vers cette valeur comme paramètre de fonction, puis effectuer les modifications nécessaires.

8. La fonction "nouvelle" dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? 🎜🎜La fonction 🎜nouvelle🎜 dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ? 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, tout 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 Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?. 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 Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?🎜🎜L'arithmétique des pointeurs n'est pas autorisée dans Quest-ce quun pointeur Go ? Quels sont les points de connaissances à maîtriser ?. 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. 🎜🎜🎜Adresse originale : https://golangdocs.com/pointers-in-golang🎜🎜Adresse de traduction : https://learnku.com/go/t/60880🎜🎜

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!