go八：函数的参数传递

int、string，及其指针作为参数：

package main

import "fmt"

func main() {
    a := 10
    fmt.Printf("1、执行函数前的变量a的内存地址：%p, 值为：%v\n", &a, a)  //0xc04204c080, 10
    //传值：不改变变量原来的值
    changeIntVal(a)
    fmt.Printf("2、changeIntVal函数调用后，变量a的内存地址：%p, 值为：%v\n", &a, a)  //0xc04204c080, 10
    //传引用：将改变变量原来的值
    changeIntPtr(&a)
    fmt.Printf("3、changeIntPtr函数调用后，变量a的内存地址：%p, 值为：%v\n", &a, a)  //0xc04204c080, 200

}
func changeIntVal(a int) {
    fmt.Printf("changeIntVal函数内：值参数a的内存地址：%p，值：%v\n", &a, a )  //0xc04204c0a0，10
    a = 90
}
func changeIntPtr(a *int) {
    fmt.Printf("changeIntPtr函数内：指针参数a的内存地址：%p，值：%v\n", &a, a )  //0xc04206c020，0xc04204c080
    *a = 200
}

数组、数组指针作为参数：

package main

import (
    "fmt"
)

func main() {
    a := [4]int{1, 2, 3, 4}
    fmt.Printf("1、执行函数前的变量a的内存地址：%p, 值为：%v\n", &a, a) //0xc04204c080, [1 2 3 4]
    //传值：不改变变量原来的值
    changeArrayVal(a)
    fmt.Printf("2、changeIntVal函数调用后，变量a的内存地址：%p, 值为：%v\n", &a, a) //0xc04204c080, [1 2 3 4]
    //传引用：将改变变量原来的值
    changeArrayPtr(&a)
    fmt.Printf("3、changeIntPtr函数调用后，变量a的内存地址：%p, 值为：%v\n", &a, a) //0xc04204c080, [1 33 3 4]

}
func changeArrayVal(a [4] int) {
    fmt.Printf("changeIntVal函数内：值参数a的内存地址：%p，值：%v\n", &a, a) //0xc04204c0a0，[1 2 3 4]
    a[0] = 99
}
func changeArrayPtr(a *[4]int) {
    fmt.Printf("changeIntPtr函数内：指针参数a的内存地址：%p，值：%v\n", &a, a) //0xc04206c020，&[1 2 3 4]
    (*a)[1] = 33
}

 

切片、切片指针作为参数：

package main

import (
    "fmt"
)

func main() {
    a := []int{1, 2, 3, 4}
    fmt.Printf("1、执行函数前的变量a的内存地址：%p, 值为：%v\n", &a, a) //0xc04204c080, [1 2 3 4]
    //传值：不改变变量原来的值
    changeArrayVal(a)
    fmt.Printf("2、changeIntVal函数调用后，变量a的内存地址：%p, 值为：%v\n", &a, a) //0xc04204c080, [99 2 3 4]
    //传引用：将改变变量原来的值
    changeArrayPtr(&a)
    fmt.Printf("3、changeIntPtr函数调用后，变量a的内存地址：%p, 值为：%v\n", &a, a) //0xc04204c080, [99 33 3 4]

}
func changeArrayVal(a [] int) {
    fmt.Printf("changeIntVal函数内：值参数a的内存地址：%p，值：%v\n", &a, a) //0xc04204c0a0，[99 2 3 4]
    a[0] = 99
}
func changeArrayPtr(a *[]int) {
    fmt.Printf("changeIntPtr函数内：指针参数a的内存地址：%p，值：%v\n", &a, a) //0xc04206c020，&[1 2 3 4]
    (*a)[1] = 33
}

struct、struct指针作为参数：

package main

import (
    "fmt"
)

type Teacher struct {
    name string
    age int
    married bool
    sex int8
}
func main() {
    a := Teacher{"bob", 25, false, 1}
    fmt.Printf("1、执行函数前的变量a的内存地址：%p, 值为：%v\n", &a, a) //0xc04204c080, {bob 25 false 1}
    //传值：不改变变量原来的值
    changeStructVal(a)
    fmt.Printf("2、changeIntVal函数调用后，变量a的内存地址：%p, 值为：%v\n", &a, a) //0xc04204c080, {bob 25 false 1}
    //传引用：将改变变量原来的值
    changeStruckPtr(&a)
    fmt.Printf("3、changeIntPtr函数调用后，变量a的内存地址：%p, 值为：%v\n", &a, a) //0xc04204c080,{ellen 50 false 1}

}
func changeStructVal(a Teacher) {
    fmt.Printf("changeIntVal函数内：值参数a的内存地址：%p，值：%v\n", &a, a) //0xc04204c0a0，{bob 25 false 1}
    a.age = 42
    a.name = "davied"
}
func changeStruckPtr(a *Teacher) {
    fmt.Printf("changeIntPtr函数内：指针参数a的内存地址：%p，值：%v\n", &a, a) //0xc04206c020，&{bob 25 false 1}
    a.age = 50
    a.name = "ellen"
}

 

package main
import (
   "fmt"
)
type person struct {
   id int
   name string
   score int
}
func test(s person) {
   s.name = "张飞"
   fmt.Println(s.id, s.name, s.score)  //101 张飞 99
}
func main() {
   //结构体，作为参数传递
   stu := person{101, "宋江", 99}
   test(stu)
   fmt.Println(stu) //{101 宋江 99} 
}

package main

import (
   "fmt"
)

type person struct {
   id int
   name string
   score int
}
func test(s []person) {
   s[0].name = "张飞"
   fmt.Println(s)  //[{101 张飞 99} {102 宋江2 99} {103 宋江3 99}]
}
func main() {
   //结构体切片，作为参数传递
   s := []person{person{101, "宋江1", 99}, person{102, "宋江2", 99}}
   //为切片添加元素
   s = append(s, person{103, "宋江3", 99})
   //切片，是指针传递，引用传递
   test(s)
   fmt.Println(s)   //[{101 张飞 99} {102 宋江2 99} {103 宋江3 99}]

总结：

• 所有指针作为参数，都属于指针引用，会改变原来的变量的值。
• int、string作为参数时，属于传值，不会改变原来的变量的值。
•  数组作为参数，也属于传值，不会改变原来的变量的值。
• 切片作为参数，属于指针引用，会改变原来的变量的值