Go-Sprachfunktion parameter

FunktionIn Golang sind das eine Sammlung von Anweisungen, die zur Ausführung spezifischer Aufgaben dienen und das Ergebnis an den Aufrufer zurückgeben. Funktionen können auch spezifische Aufgaben ausführen, ohne etwas zurückzugeben. Golang unterstützt zwei Arten der Übermittlung von Parametern an Funktionen, nämlichÜberweisung nach Wert oder WertaufrufsowieÜberweisung nach Verweis oder Überweisung nach Verweis. Standardmäßig verwendet Golang den Wertaufruf, um Parameter an Funktionen zu übergeben.

Basisbegriffe der Parameterübergabe an die Funktion:

• Der Parameter, der an die Funktion übergeben wird, wird als tatsächlicher Parameter bezeichnet.

• Der Parameter, den die Funktion empfängt, wird als formeller Parameter bezeichnet.

Wertaufruf

Bei diesem Parameterübergabe wird der Wert des tatsächlichen Parameters in den formalen Parameter der Funktion kopiert, und beide Arten von Parametern werden in verschiedenen Speicherorten gespeichert. Daher werden alle Änderungen, die im Funktionsinneren vorgenommen werden, nicht auf den tatsächlichen Parameter des Aufrufers zurückgemeldet.

Beispiel1:In dem folgenden Programm können Sie sehen, dass der Wert von Z nicht durch die Modify-Funktion geändert werden kannÄndern.

package main
import "fmt"
//　Funktion Wert ändern
func modify(Z int) {
　　　　Z =　70
}
func main() {
　　　　var Z int =　10
　　　　fmt.Printf("Funktion aufruf vor, der Wert von Z ist = %d", Z)
　　　　//Wertaufruf
　　　　modify(Z)
　　　　fmt.Printf("\nFunktion aufruf nach, der Wert von Z ist = %d", Z)
}

Ausgabe:

Funktion aufruf vor, der Wert von Z ist =　10
函数调用后，Z的值为　=　10

Beispiel2:Nach dem Funktionsaufruf beträgt der Wert von Z =

package main
import "fmt"
//Im folgenden Programm kann die Tauschfunktion keine Werte tauschen, da wir nach Wertaufruf verwenden.
Funktion zum Tauschen von Werten
　　　　//func swap(x, y int) int {
　　　　var tmp int
　　　　Nehmen Sie eine temporäre Variable
　　　　tmp = x
　　　　y = tmp
　　　　return tmp
}
func main() {
　　　　var f int =　700
　　　　var s int =　900
　　　　fmt.Printf("Funktionsergebnis vor dem Aufruf\n")
　　　　x = y
　　　　fmt.Printf("f = %d und s = %d\n", f, s)
　　　　fmt.Printf("\nFunktionsergebnis nach dem Aufruf\n")
　　　　swap(f, s)
}

Ausgabe:

Funktionsergebnis vor dem Aufruf
f =　7fmt.Printf("f = %d und s = %d", f, s)　900
Funktionsergebnis
f =　7fmt.Printf("f = %d und s = %d", f, s)　900

00 und s =

ReferenzaufrufHier verwenden SieZeiger (Pointers)*Konception. Der Dereferenzierungsoperator

Beispiel1:um auf den Wert im Speicherort zuzugreifen. Der Adressoperator & wird verwendet, um die Adresse eines Variablen jeder Datentyp zu erhalten. Die tatsächlichen Parameter und die formalen Parameter verweisen auf den gleichen Ort, daher spiegeln sich alle Änderungen, die im Funktionsinneren vorgenommen werden, tatsächlich im tatsächlichen Parameter des Aufrufers wider.*Werte ändern. Daher werden im Funktionsaufruf die Adressen der Variablen übergeben und der Dereferenzierungsoperator verwendetNach dem ÄndernFinden Sie nach dem Ändern den aktualisierten Wert.

package main
import "fmt"
//　Funktion zum Ändern von Werten
func modifydata(Z　*int) {
　　　　*Z =　70
}
func main() {
　　　　var Zz int =　10
　　　　fmt.Printf("Vor dem Funktionsaufruf beträgt der Wert von Zz = %d", Zz)
　　　　//Übermittlung der Variable Zs Adresse durch Referenzaufruf
　　　　modifydata(&Zz)
　　　　fmt.Printf("\nNach dem Funktionsaufruf beträgt der Wert von Zz = %d", Zz)
}

Ausgabe:

Vor dem Funktionsaufruf beträgt der Wert von Zz =　10
Nach dem Funktionsaufruf beträgt der Wert von Zz =　70

Beispiel2:Durch die Verwendung von Referenzaufrufen kann die Tauschfunktion Werte wie folgt tauschen.

package main
import "fmt"
//Funktion zum Tauschen von Werten, die auf Ganzzahlenzeiger verweisen
func swap(x, y　*int) int {
　　　　//Temporäre Speicherung von Variablen
　　　　var tmp int
　　　　tmp =　*x
　　　　*x =　*y
　　　　*y = tmp
　　　　return tmp
}
func main() {
　　　　var f int =　700
　　　　var s int =　900
　　　　fmt.Printf("Funktionsergebnis vor dem Aufruf\n")
　　　　fmt.Printf("f = %d und s = %d\n", f, s)
　　　　//Durch Referenzaufruf
　　　　//Übermittlung der Variablenadresse
　　　　swap(&f, &s)
　　　　fmt.Printf("\nFunktionsergebnis nach dem Aufruf\n")
　　　　fmt.Printf("f = %d und s = %d", f, s)
}

Ausgabe:

Funktionsergebnis vor dem Aufruf
f =　700 und s ==　900
Funktionsergebnis
f =　900 und s ==　700