理解指针
什么是指针？
指针是一种特殊的类型，指针变量的值是一个地址，该地址指向一个“指针类型”的变量
指针声明
var 指针变量名 *指针类型
示例
package main
import(
"fmt"
)
func main() {
var int_value = 10
var int_ptr = &int_value
fmt.Printf("The value of int_value %v\n", int_value)
fmt.Printf("The pointer of int_value %p\n", &int_value)
fmt.Printf("The value of int_ptr %v\n", int_ptr)
fmt.Printf("The pointer of int_ptr %p\n", &int_ptr)
var int_ptr_other *int
int_ptr_other = int_ptr
fmt.Printf("The value of int_ptr_other %v\n", int_ptr_other)
fmt.Printf("The pointer of int_ptr_other %p\n", &int_ptr_other)
// var string_ptr *string
// string_ptr = &int_ptr
// cannot use &int_ptr (type **int) as type *string in assignment
}
输出
The value of int_value 10
The pointer of int_value 0xc210000018
The value of int_ptr 0xc210000018
The pointer of int_ptr 0xc210000020
The value of int_ptr_other 0xc210000018
The pointer of int_ptr_other 0xc210000028
内存布局
map 引用类型
示例
package main
import(
"fmt"
"reflect"
)
func main() {
var m map[string]int
// https://blog.golang.org/go-maps-in-action
// Map types are reference types, like pointers or slices, and so the value of m above is nil;
// it doesn't point to an initialized map. A nil map behaves like an empty map when reading,
// but attempts to write to a nil map will cause a runtime panic; don't do that.
// To initialize a map, use the built in make function
// Map类型 是引用类型，因此 m 的值为 nil
fmt.Printf("type of un-initialized map reference %v\n", reflect.TypeOf(m))
fmt.Printf("type of the pointer of map reference %v\n", reflect.TypeOf(&m))
fmt.Printf("The un-initialized map reference %p\n", m)
fmt.Printf("The pointer of map reference %p\n", &m)
// The make function allocates and initializes a hash map data structure
// and returns a map value that points to it. The specifics of that data structure
// are an implementation detail of the runtime and are not specified by the language itself.
// make函数将会分配并初始化一个底层hash map结构，然后返回一个 map 值，该值指向底层的hash map结构
m = make(map[string]int)
fmt.Printf("The initialized map reference %p\n", m)
fmt.Printf("type of initialized map reference %v\n", reflect.TypeOf(m))
fmt.Printf("The pointer of map reference %p\n", &m)
}
输出
type of un-initialized map reference map[string]int
type of the pointer of map reference *map[string]int
The un-initialized map reference 0x0
The pointer of map reference 0xc210000018
The initialized map reference 0xc2100381e0
type of initialized map reference map[string]int
The pointer of map reference 0xc210000018
内存布局
map作为参数传递
示例
package main
import(
"fmt"
)
// Map types are reference types
func main() {
person := make(map[string]string)
person["name"] = "nogo"
fmt.Printf("person变量的内存地址是：%p\n", &person)
fmt.Printf("原始map的内存地址是：%p\n", person)
modify(person)
fmt.Println("map值被修改了，新值为:",person)
}
func modify(person_inner map[string]string){
fmt.Printf("person_inner变量的内存地址是：%p\n",&person_inner)
fmt.Printf("函数内map的内存地址是：%p\n",person_inner)
person_inner["age"] = "17"
}
输出
person变量的内存地址是：0xc210000018
原始map的内存地址是：0xc2100381b0
person_inner变量的内存地址是：0xc210000020
函数内map的内存地址是：0xc2100381b0
map值被修改了，新值为: map[name:nogo age:17]
内存布局
解释
首先我们要明确：在 Go 中不存在引用传递，所有的参数传递都是值传递。
person_inner 变量实际上是 person 变量的拷贝，其值也为指向底层hash map的指针，因此可以改变原生map的数据。
