Vai - Chiama per riferimento

Il call by referenceIl metodo per passare argomenti a una funzione copia l'indirizzo di un argomento nel parametro formale. All'interno della funzione, l'indirizzo viene utilizzato per accedere all'argomento effettivo utilizzato nella chiamata. Ciò significa che le modifiche apportate al parametro influiscono sull'argomento passato.

Per passare il valore per riferimento, i puntatori agli argomenti vengono passati alle funzioni proprio come qualsiasi altro valore. Di conseguenza è necessario dichiarare i parametri della funzione come tipi di puntatore come nella funzione seguenteswap(), che scambia i valori delle due variabili intere puntate dai suoi argomenti.

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

Per saperne di più sui puntatori nella programmazione Go, passare a Go - Pointers.

Per ora, chiamiamo la funzione swap () passando i valori per riferimento come nell'esempio seguente:

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

Metti il ​​codice sopra in un singolo file Go, quindi compilalo ed eseguilo. Produce il seguente risultato:

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

Mostra che la modifica si è riflessa anche all'esterno della funzione, a differenza della chiamata per valore in cui le modifiche non si riflettono all'esterno della funzione.