Aller - Appel par référence

le call by referenceLa méthode de transmission d'arguments à une fonction copie l'adresse d'un argument dans le paramètre formel. À l'intérieur de la fonction, l'adresse est utilisée pour accéder à l'argument réel utilisé dans l'appel. Cela signifie que les modifications apportées au paramètre affectent l'argument passé.

Pour passer la valeur par référence, des pointeurs d'argument sont passés aux fonctions comme toute autre valeur. En conséquence, vous devez déclarer les paramètres de fonction en tant que types de pointeur comme dans la fonction suivanteswap(), qui échange les valeurs des deux variables entières pointées par ses arguments.

/* function definition to swap the values */
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* save the value at address x */
   *x = *y      /* put y into x */
   *y = temp    /* put temp into y */
}

Pour en savoir plus sur les pointeurs dans la programmation Go, veuillez consulter Go - Pointers.

Pour l'instant, appelons la fonction swap () en passant des valeurs par référence comme dans l'exemple suivant -

package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200

   fmt.Printf("Before swap, value of a : %d\n", a )
   fmt.Printf("Before swap, value of b : %d\n", b )

   /* calling a function to swap the values.
   * &a indicates pointer to a ie. address of variable a and 
   * &b indicates pointer to b ie. address of variable b.
   */
   swap(&a, &b)

   fmt.Printf("After swap, value of a : %d\n", a )
   fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* save the value at address x */
   *x = *y    /* put y into x */
   *y = temp    /* put temp into y */
}

Placez le code ci-dessus dans un seul fichier Go, puis compilez-le et exécutez-le. Il produit le résultat suivant -

Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :200
After swap, value of b :100

Il montre que le changement s'est également reflété à l'extérieur de la fonction, contrairement à l'appel par valeur où les changements ne se reflètent pas à l'extérieur de la fonction.