Paramètres de fonction Go

FonctionDans Golang, les fonctions sont des ensembles d'instructions utilisées pour exécuter des tâches spécifiques et renvoyer des résultats à l'appelant. Les fonctions peuvent également exécuter certaines tâches spécifiques sans renvoyer de contenu. Golang prend en charge deux façons de transmettre des paramètres à une fonction, à savoirTransmission par valeur ou appel par valeuretTransmission par référence ou transmission par référence.Par défaut, Golang utilise le mode d'appel par valeur pour transmettre des paramètres à la fonction.

Termes de base pour la transmission de paramètres à une fonction :

• Les paramètres passés à la fonction sont appelés paramètres réels.

• Les paramètres reçus par la fonction sont appelés paramètres formels.

Appel par valeur

Dans cette transmission de paramètres, la valeur réelle du paramètre est copiée dans le paramètre formel de la fonction, et les deux types de paramètres sont stockés dans des emplacements de stockage différents. Par conséquent, toute modification effectuée à l'intérieur de la fonction ne se reflétera pas dans le paramètre réel de l'appelant.

Exemple1:Dans le programme suivant, vous pouvez voir que la valeur de Z ne peut pas être modifiée par la fonction ModifyModification.

package main
import "fmt"
//　Modification de la valeur de la fonction
func modify(Z int) {
　　　　Z = =　70
}
func main() {
　　　　var Z int =　10
　　　　fmt.Printf("Avant l'appel de la fonction, la valeur de Z est égale à %d", Z)
　　　　//Appel par valeur
　　　　modify(Z)
　　　　fmt.Printf("\nAprès l'appel de la fonction, la valeur de Z est égale à %d", Z)
}

Sortie :

Avant l'appel de la fonction, la valeur de Z est égale à　10
La valeur de Z après l'appel de la fonction est = =　10

Exemple2:Dans le programme suivant, la fonction d'échange ne peut pas échanger de valeurs car nous utilisons l'appel par valeur.

package main
import "fmt"
//Fonction d'échange de valeurs
func swap(x, y int) int {
　　　　//Prendre une variable temporaire
　　　　var tmp int
　　　　tmp = = x
　　　　x = = y
　　　　y = = tmp
　　　　return tmp
}
func main() {
　　　　var f int = =　700
　　　　var s int = =　900
　　　　fmt.Printf("La valeur avant l'appel de la fonction\n")
　　　　fmt.Printf("f = = %d et s = = %d\n", f, s)
　　　　swap(f, s)
　　　　fmt.Printf("\nLa valeur après l'appel de la fonction\n")
　　　　fmt.Printf("f = = %d et s = = %d", f, s)
}

Sortie :

La valeur avant l'appel de la fonction
f = =　700 et s = =　900
La valeur après l'appel de la fonction
f = =　700 et s = =　900

Appel par référence

Ici, vous utiliserezPointeurs (pointeurs)de l'opérateur de déréférencement*Pour accéder aux valeurs de l'adresse. L'opérateur d'adresse & est utilisé pour obtenir l'adresse de tout type de données. Les arguments réels et les arguments formels pointent vers la même position, par conséquent, toute modification faite à l'intérieur de la fonction se reflète réellement dans les arguments réels appelants.

Exemple1:Dans l'appel de la fonction, nous passons l'adresse de la variable et utilisons l'opérateur de déréférencement*Modification de valeurs. Par conséquent, dans la fonctionModification aprèsVous trouverez la valeur mise à jour après

package main
import "fmt"
//　Fonction de modification de valeurs
func modifydata(Z　*int) {
　　　　*Z = =　70
}
func main() {
　　　　var Zz int = =　10
　　　　fmt.Printf("La valeur avant l'appel de la fonction, Zz vaut = = %d", Zz)
　　　　//Adresse de la variable Z passée par référence
　　　　modifydata(&Zz)
　　　　fmt.Printf("\nLa valeur après l'appel de la fonction, Zz vaut = = %d", Zz)
}

Sortie :

La valeur de Zz avant l'appel de la fonction est = =　10
La valeur de Zz après l'appel de la fonction est = =　70

Exemple2:En utilisant l'appel par référence, la fonction d'échange peut échanger des valeurs, comme indiqué ci-dessous.

package main
import "fmt"
//Fonction d'échange de valeurs, pointant vers des entiers
func swap(x, y　*int) int {
　　　　//Variable de stockage temporaire
　　　　var tmp int
　　　　tmp = =　*x
　　　　*x = =　*y
　　　　*y = = tmp
　　　　return tmp
}
func main() {
　　　　var f int = =　700
　　　　var s int = =　900
　　　　fmt.Printf("La valeur avant l'appel de la fonction\n")
　　　　fmt.Printf("f = = %d et s = = %d\n", f, s)
　　　　//Appel par référence
　　　　//Passage de l'adresse de la variable
　　　　swap(&f, &s)
　　　　fmt.Printf("\nLa valeur après l'appel de la fonction\n")
　　　　fmt.Printf("f = = %d et s = = %d", f, s)
}

Sortie :

La valeur avant l'appel de la fonction
f = =　700 et s ==　900
La valeur après l'appel de la fonction
f = =　900 et s ==　700