参数传递是指在程序的传递过程中，实际参数就会将参数值传递给相应的形式参数，然后在函数中实现对数据处理和返回的过程。比较常见的参数传递有：值传递，按地址传递参数或者按数组传递参数.

1、常规传递

使用普通变量作为函数参数的时候，在传递参数时只是对变量值的拷贝，即将实参的值复制给变参，当函数对变参进行处理时，并不会影响原来实参的值。

egg:

packagemain

import"fmt"

funcaa(a,bint){

vartempint

temp=a

a=b

b=temp

fmt.Println(a,b)//处理了a,b交换的值

}

funcmain(){

x:=5

y:=10

aa(x,y)

fmt.Println(x,y)//交换后还是打印原来的值

}

输出结果：

C:/Users/cherry/go/src/aa/aa.exe [C:/Users/cherry/go/src/aa]

10 5

5 10

成功: 进程退出代码 0.

2、指针函数

函数的变量不仅可以使用普通变量，还可以使用指针变量，使用指针变量作为函数的参数时，在进行参数传递时将是一个地址，即将实参的内存地址复制给变参，这时变参的修改也将会影响到实参的值。

egg:

packagemain

import"fmt"

funcaa(a*int,b*int){

vartempint

temp=*a

*a=*b

*b=temp

//fmt.Println(temp,*a,*b)

}

funcmain(){

x:=5

y:=10

aa(&x,&y)

fmt.Println(x,y)

}

执行结果：

C:/Users/cherry/go/src/aa/aa.exe [C:/Users/cherry/go/src/aa]

10 5

成功: 进程退出代码 0.


3、数组元素作为函数参数

使用数组元素作为参数时，其使用的方法和普通变量相同，既是一个"值拷贝"

packagemain

import"fmt"

funcaa(aint){

a+=100

fmt.Printf("打印内部的累加后的值:%d\n",a)

}

funcmain(){

vars=[...]int{1,2,3,4,5,6}

fmt.Printf("开始调用函数....\n")

aa(s[3])

fmt.Printf("调用结束...")

fmt.Println(s[3])

}

执行结果：

C:/Users/cherry/go/src/aa/aa.exe [C:/Users/cherry/go/src/aa]

开始调用函数....

打印内部的累加后的值:104

调用结束...4

成功: 进程退出代码 0.

4、数组名作为函数参数：和其他语言不同的是,GO语言在将数组名字作为函数参数的时候，参数传递既是对数组的复制，在形参中对数组元素的修改都不会影响到数组元素的原来的值，CODE如下：

packagemain

import"fmt"

funcaa(s[6]int){

s[3]+=100

fmt.Printf("打印内部的累加后的值:%d\n",s)

}

funcmain(){

vars=[...]int{1,2,3,4,5,6}

fmt.Printf("开始调用函数....\n")

aa(s)

fmt.Printf("调用结束...")

fmt.Println(s)

}

执行结果：

C:/Users/cherry/go/src/aa/aa.exe [C:/Users/cherry/go/src/aa]

开始调用函数....

打印内部的累加后的值:[1 2 3 104 5 6]

调用结束...[1 2 3 4 5 6]

##将数组作为参数传入时，必须指定传入数组的长度和初始定义长度一样

5、slice作为函数参数

在使用sclice作为函数参数时，进行参数传递将是一个地址拷贝，即将底层数组的内存地址复制给参数slice，对slice元素的操作就是对底层数组元素的操作。

egg:

packagemain

import"fmt"

funcaa(s1[]int){

s1[0]+=100

}

funcmain(){

vara=[5]int{1,2,3,4,5}

vars[]int=a[0:]

aa(s)

fmt.Println(s[0])

fmt.Println(a)

}

执行结果：

C:/Users/cherry/go/src/aa/aa.exe [C:/Users/cherry/go/src/aa]

101

[101 2 3 4 5]//原数组的的值发生了变化

6、函数作为参数:GO语言中，函数也作为一种数据类型，所以函数也可以作为函数的参数来使用。

packagemain

import"fmt"

funcaa(a,bint,bbfunc(int,int)int){

fmt.Println(bb(a,b))

}

funcbb(a,bint)int{

returna+b

}

funcmain(){

vara,bint=5,6

f:=bb

fmt.Println(f)

aa(a,b,f)

fmt.Println(a,b,f)


}

函数bb作为函数aa的形参，而变量f是一个函数类型，作为aa()调用时的实参