Quelle est la différence entre le récepteur d'une méthode en golang étant un pointeur et ne pas être un pointeur ?

La colonne suivante du tutoriel golang vous donnera une explication détaillée de la différence entre le récepteur de la méthode dans golang être un pointeur et ne pas être un pointeur. J'espère aider ceux qui en ont besoin !

Préface

Récemment, un étudiant a demandé sur le site quelle est la différence entre le récepteur d'une méthode en golang étant un pointeur et ne pas être un pointeur . Ici, je vais l'expliquer de manière simple et facile à comprendre. La méthode est expliquée pour aider les étudiants qui viennent d'apprendre le golang

Qu'est-ce que la méthode

En fait, comme. tant que vous comprenez ce principe, vous pouvez fondamentalement comprendre les problèmes mentionnés ci-dessus.

Une méthode est en fait une fonction spéciale, et le récepteur est le premier paramètre transmis implicitement

.

Par exemple,

type test struct{
    name string
}

func (t test) TestValue() {
}

func (t *test) TestPointer() {
}

func main(){
    t := test{}
    
    m := test.TestValue
    m(t)
    
    m1 := (*test).TestPointer
    m1(&t)    
}

N'est-ce pas facile à comprendre ? Ajoutons maintenant du code pour voir la différence entre les pointeurs et les non-pointeurs.

type test struct{
    name string
}

func (t test) TestValue() {
    fmt.Printf("%p\n", &t)
}

func (t *test) TestPointer() {
    fmt.Printf("%p\n", t)
}

func main(){
    t := test{}
    //0xc42000e2c0
    fmt.Printf("%p\n", &t)
    
    //0xc42000e2e0
    m := test.TestValue
    m(t)
    
    //0xc42000e2c0
    m1 := (*test).TestPointer
    m1(&t)    

}

Je suppose que certains étudiants l'ont déjà fait. compris que lorsque les paramètres réels ne sont pas des pointeurs, la valeur est copiée. Donc à chaque fois Une copie de la valeur TestValue() se produit.
Quel sera le résultat si cela implique l'opération de modification de la valeur ?

type test struct{
    name string
}

func (t test) TestValue() {
    fmt.Printf("%s\n",t.name)
}

func (t *test) TestPointer() {
    fmt.Printf("%s\n",t.name)
}

func main(){
    t := test{"wang"}

    //这里发生了复制,不受后面修改的影响
    m := t.TestValue
    
    t.name = "Li"
    m1 := (*test).TestPointer
    //Li
    m1(&t)    
    
    //wang
    m()
}

Tous les étudiants doivent donc faire attention lorsqu'ils rencontrent de tels problèmes de programmation
Alors, quelle est la relation entre ces ensembles de méthodes ? J'emprunte ici les notes de lecture de qyuhen sur golang (https://github.com/qyuhen/book) ? . Je recommande également aux amis qui aiment le golang de lire ce livre, il est très utile pour approfondir la compréhension du golang.

• L'ensemble de méthodes de type T contient toutes les méthodes du récepteur T.
• L'ensemble des méthodes de type T contient toutes les méthodes du récepteur T + T.
• Si le type S contient un champ anonyme T, alors l'ensemble de méthodes de S contient T méthodes.
• Si le type S contient le champ anonyme T, alors l'ensemble de méthodes de S contient les méthodes T + T.
• Indépendamment de l'intégration de T ou T, l'ensemble des méthodes S contient toujours les méthodes T + *T.

Conclusion

Bien que Golang soit simple et facile à utiliser, il présente encore de nombreux pièges L'auteur a rencontré de nombreux pièges dans le processus d'utilisation de Golang, qui seront mentionnés dans le blog. plus tard. Tout le monde est le bienvenu. Discutons ensemble.

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!