Aller au mécanisme de transmission des paramètres de type pointeur

Il existe deux manières de transmettre des paramètres de type pointeur dans Go : passage de valeur : la fonction obtient une copie du pointeur et les modifications apportées à la copie n'affectent pas le pointeur d'origine. Passer par référence : la fonction obtient une référence au pointeur d'origine et les modifications apportées à la référence affectent le pointeur d'origine.

Mécanisme de transmission des paramètres de type pointeur Go

Dans Go, les paramètres de type pointeur sont transmis aux fonctions de deux manières différentes : transmission de valeur et transmission de référence.

Passage par valeur

Si vous transmettez une valeur de pointeur à une fonction en tant que valeur, la fonction obtiendra une copie de ce pointeur. Toute modification apportée à cette copie n’affectera pas le pointeur d’origine.

Exemple de code :

package main

import "fmt"

func changeValue(ptr *int) {
    *ptr = 10
}

func main() {
    ptr := new(int)
    *ptr = 5
    fmt.Println(*ptr) // 输出: 5

    changeValue(ptr)
    fmt.Println(*ptr) // 输出: 5
}

Pass by Reference

Si vous transmettez une adresse de pointeur en tant que valeur à une fonction, la fonction obtiendra une référence au pointeur d'origine. Toute modification apportée à cette référence affectera le pointeur d'origine.

Exemple de code :

package main

import "fmt"

func changePointer(ptr **int) {
    *ptr = new(int)
    **ptr = 10
}

func main() {
    ptr := new(int)
    *ptr = 5
    fmt.Println(*ptr) // 输出: 5

    changePointer(&ptr)
    fmt.Println(*ptr) // 输出: 10
}

Cas pratique

Dans le cas pratique suivant, nous utilisons le passage de valeur et le passage de références pour implémenter une simple liste chaînée.

Implémentation d'une liste chaînée en utilisant le passage par valeur :

type Node struct {
    value int
    next *Node
}

func createList(values []int) *Node {
    head := &Node{value: values[0]}
    current := head

    for _, v := range values[1:] {
        next := &Node{value: v}
        current.next = next
        current = next
    }

    return head
}

func printList(head *Node) {
    for current := head; current != nil; current = current.next {
        fmt.Printf("%d ", current.value)
    }
    fmt.Println()
}

func main() {
    values := []int{1, 2, 3, 4, 5}
    head := createList(values)
    printList(head) // 输出: 1 2 3 4 5
}

Implémentation d'une liste chaînée en utilisant le passage par référence :

type Node struct {
    value int
    next **Node
}

func createList(values []int) *Node {
    head := &Node{value: values[0]}
    current := head

    for _, v := range values[1:] {
        next := &Node{value: v}
        *current.next = next
        current = next
    }

    return head
}

func printList(head *Node) {
    for current := head; current != nil; current = *current.next {
        fmt.Printf("%d ", current.value)
    }
    fmt.Println()
}

func main() {
    values := []int{1, 2, 3, 4, 5}
    head := createList(values)
    printList(head) // 输出: 1 2 3 4 5
}

Dans le premier exemple, nous créons une liste chaînée en utilisant le passage par valeur. Dans le deuxième exemple, nous créons une liste chaînée en utilisant le passage par référence. Les résultats d'exécution sont les mêmes, mais lors du passage par référence, on peut modifier l'ordre de la liste chaînée dans la fonction.

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!