golang：指针传参

函数指针与指针函数

函数指针:是指向函数的指针变量，即本质是一个指针变量。
指针函数:本质是一个函数。函数返回类型是某一类型的指针。

package main

import "fmt"



func main() {
	// 函数指针：是一个指针，指向一个函数
	fmt.Printf("函数add的类型：%T\n", add) // 函数add的类型：func(int, int) int
	fmt.Println("打印add函数：", add) //  0x1095bc0,函数的地址，可以理解为一个特殊的变量。
	fmt.Println("函数的执行结果：", add(100, 200)) //300

	var f1 func(int, int) int = add  // 函数f1和add一样，指向同一个函数
	fmt.Println("打印f1函数：", f1) //打印f1函数： 0x4986b0
	fmt.Println("函数的执行结果：", f1(100, 200)) //300
	/*
 	结论：函数声明时，函数名本身就是一个指针。不需要加*。
			函数与函数赋值时，属于浅拷贝，拷贝指针，两个指针同时指向同一块内存空间。
 */


	res1 := fun1 // 是一个指针，指向一个函数，函数结果返回一个指针
	fmt.Printf("res1:%p,%v\n",res1,res1()) // res1:0x498900,&[1 3 5 7]
	res2 := fun1() // 是一个调用函数之后返回的指针，指向 [4]int 存储4个int类型的数组
	fmt.Printf("res2:%p,%v\n",res2,*res2) //res2:0xc04200e320,[1 3 5 7]



}

// 1.定义一个函数，求两个数的和
// 该函数的类型：func (int,int) int
func add(a, b int) int  {
	return a + b
}

//2.定义一个指针函数
func fun1() *[4]int{
	var arr [4] int
	for i:=0;i<len(arr);i++{
		arr[i] = i*2+1
	}
	fmt.Printf("数组地址：%p，数组内容：%v\n",&arr,arr) //[1 3 5 7]
	return &arr
}

整数指针作为函数传参

package main

import "fmt"

func IntPoint(a *int){
	*a = *a + 1;
}

func main() {
	a := 1;
	IntPoint(&a)
	fmt.Print(a)  // 数值为2
}

map作为函数传参

package main

import "fmt"

func MapPoint(temp map[string]string){
	temp["cd"] = "gtfrdesxxcf"
	temp["ls"] = "11111111111111111111"
}

func main() {
	a := map[string]string{
		"bidlj":"1",
		"cd":"0",
	}
	MapPoint(a)
	fmt.Print(a) //map[bidlj:1 cd:gtfrdesxxcf ls:11111111111111111111]
}

数组作为函数传参

package main

import "fmt"

func MapPoint(temp map[string]string){
	temp["cd"] = "gtfrdesxxcf"
	temp["ls"] = "11111111111111111111"
}

func ArrayPoint(temp *[]map[string]string){
	(*temp) = append((*temp), map[string]string{
		"vv":"aaa",
		"aa": "aaaaaaaaa",
	})
}

func main() {
	a := make([]map[string]string, 0)
	a = append(a, map[string]string{
		"bidlj":"1",
		"cd":"0",
	})
	ArrayPoint(&a)
	fmt.Print(a) //[map[bidlj:1 cd:0] map[aa:aaaaaaaaa vv:aaa]]
}