Go语言值传递和引用传递

Go 语言中的函数可以有一个或多个参数，每个参数后面都带有类型，通过“,”符号分隔。如果参数列表中若干个相邻参数的类型相同，则可以在参数列表中省略前面变量的类型声明，例如：

func add(a,b int) (ret int, err error) {
}

如果返回值列表中多个返回值的类型相同，也可以使用同样的方式合并。如果函数只有一个返回值，可以写成如下形式：

func add(a,b int) int {
}

函数如果使用参数，该变量可称为函数的形参。形参就像定义在函数体内的局部变量。

调用函数，可以通过两种方式来传递参数，分别是值传递和引用传递。

值传递

值传递是指在调用函数时将实际参数复制传递到函数中，这样在函数中如果对参数进行修改，将不会影响实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响实际参数。

定义 swap() 函数：

/*定义相互交换值的函数*/
func swap(x, y int) int {
   var temp int
   temp = x     /*保存 x 的值*/
   x = y        /*将 y 值赋给 x*/
   y = temp     /*将 temp 值赋给 y*/
   return temp;
}

接着使用值传递来调用 swap() 函数：

package main
import "fmt"
func main() {
   /*定义局部变量*/
   var a int = 100
   var b int = 200
   fmt.Printf("交换前 a 的值为 : %d\n", a )
   fmt.Printf("交换前 b 的值为 : %d\n", b )
   /*通过调用函数来交换值*/
   swap(a, b)
   fmt.Printf("交换后 a 的值 : %d\n", a )
   fmt.Printf("交换后 b 的值 : %d\n", b )
}
/*定义相互交换值的函数*/
func swap(x, y int) int {
   var temp int
   temp = x     /*保存 x 的值*/
   x = y        /*将 y 值赋给 x*/
   y = temp     /*将 temp 值赋给 y*/
   return temp;
}

运行结果为：

交换前 a 的值为 : 100
交换前 b 的值为 : 200
交换后 a 的值 : 100
交换后 b 的值 : 200

在以上代码中，使用的是值传递，所以，两个值并没有实现交互，可以使用引用传递来实现交换效果。

引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响实际参数。

引用传递指针参数传递到函数内，例如，交换函数 swap() 使用引用传递：

/*定义交换值函数*/
func swap(x *int, y *int) {
   var temp int
   temp = *x         /*保持 x 地址上的值*/
   *x = *y           /*将 y 值赋给 x*/
   *y = temp         /*将 temp 值赋给 y*/
}

通过使用引用传递来调用 swap() 函数：

package main
import "fmt"
func main() {
   /*定义局部变量*/
   var a int = 100
   var b int = 200
   fmt.Printf("交换前,a 的值 : %d\n", a)
   fmt.Printf("交换前,b 的值 : %d\n", b)
   /*调用 swap() 函数
   * &a 指向 a 指针,a 变量的地址
   * &b 指向 b 指针,b 变量的地址
   */
   swap(&a, &b)
   fmt.Printf("交换后,a 的值 : %d\n", a)
   fmt.Printf("交换后,b 的值 : %d\n", b)
}
func swap(x *int, y *int) {
   var temp int
   temp = *x         /*保存 x 地址上的值*/
   *x = *y           /*将 y 值赋给 x*/
   *y = temp         /*将 temp 值赋给 y*/
}

运行结果为：

交换前,a 的值 : 100
交换前,b 的值 : 200
交换后,a 的值 : 200
交换后,b 的值 : 100