深入了解Golang的指针用法

func main() {
	num := 1
	numP := &num
	
	//numP = 2 // 报错：(type untyped int) cannot be represented by the type *int
	*numP = 2
}

type Test struct {
	Num int
}

// 直接赋值和指针赋值
func main() {
	test := Test{Num: 1}
	test.Num = 3
	fmt.Println("v1", test) // 3

	testP := &test
	testP.Num = 4           // 结构体指针可以赋值
	fmt.Println("v2", test) // 4
}

func main() {
	nums := []int{1, 2, 3}
	fmt.Printf("%p\n", nums)     // 0xc0000160c0
	fmt.Printf("%p\n", &nums[0]) // 0xc0000160c0

	maps := map[string]string{"aa": "bb"}
	fmt.Printf("%p\n", maps) // 0xc000076180

	ch := make(chan int, 0)
	fmt.Printf("%p\n", ch) // 0xc00006c060
}

// 源码  runtime/slice.go
// 返回值是：unsafe.Pointer
func makeslice(et *_type, len, cap int) unsafe.Pointer {
	mem, overflow := math.MulUintptr(et.size, uintptr(cap))
	if overflow || mem > maxAlloc || len < 0 || len > cap {
		// NOTE: Produce a 'len out of range' error instead of a
		// 'cap out of range' error when someone does make([]T, bignumber).
		// 'cap out of range' is true too, but since the cap is only being
		// supplied implicitly, saying len is clearer.
		// See golang.org/issue/4085.
		mem, overflow := math.MulUintptr(et.size, uintptr(len))
		if overflow || mem > maxAlloc || len < 0 {
			panicmakeslicelen()
		}
		panicmakeslicecap()
	}

	return mallocGC(mem, et, true)
}

// 源码  runtime/chan.go
// 返回值是：*hchan
func makechan(t *chantype, size int) *hchan {
	elem := t.elem

	// compiler checks this but be safe.
	if elem.size >= 1<<16 {
		throw("makechan: invalid channel element type")
	}
	...
	return c
}

// 第一层源码
func Printf(fORMat string, a ...interface{}) (n int, err error) {
	return Fprintf(os.Stdout, format, a...)
}

// 第二层源码
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
	p := newPrinter()
	p.doPrintf(format, a)  // 核心
	n, err = w.Write(p.buf)
	p.free()
	return
}

// 第三层源码
func (p *pp) doPrintf(format string, a []interface{}) {
	 ...
	default:
			// Fast path for common case of ascii lower case simple verbs
			// without precision or width or argument indices.
			if 'a' <= c && c <= 'z' && argNum < len(a) {
				...
				p.printArg(a[argNum], rune(c))   // 核心是这里
				argNum++
				i++
				continue formatLoop
			}
			// Format is more complex than simple flags and a verb or is malformed.
			break simpleFormat
		}

}

// 第四层源码
func (p *pp) printArg(arg interface{}, verb rune) {
	p.arg = arg
	p.value = reflect.Value{}
  ...
	case 'p':
		p.fmtPointer(reflect.ValueOf(arg), 'p')
		return
	}
	...
}

// 最后了
func (p *pp) fmtPointer(value reflect.Value, verb rune) {
	var u uintptr
	switch value.Kind() {
  // 这里对这些特殊类型直接获取了其地址
	case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
		u = value.Pointer()
	default:
		p.badVerb(verb)
		return
	}
  ...
}

type User struct {
	Name string
	Age  int
}

// 引用传递
func setNameV1(user *User) {
	user.Name = "test_v1"
}

// 值传递
func setNameV2(user User) {
	user.Name = "test_v2"
}

func main() {
	u := User{Name: "init"}
	fmt.Println("init", u)  // init {init 0}

	up := &u
	setNameV1(up)
	fmt.Println("v1", u) // v1 {test_v1 0}

	setNameV2(u)
	fmt.Println("v2", u) // v2 {test_v1 0}
}

type User struct {
	Name string
	Age  int
}

// 注意这里有个误区，我一开始看 user（v1）打印后的地址和一开始（init）是一致的，从而以为这是引用传递
// 其实这里的user应该看做一个指针变量，我们需要对比的是它的地址，所以还要再取一次地址
func setNameV1(user *User) {
	fmt.Printf("v1: %p\n", user)  // 0xc0000a4018  与 init的地址一致
	fmt.Printf("v1_p: %p\n", &user) // 0xc0000ac020
	user.Name = "test_v1"
}

// 值传递
func setNameV2(user User) {
	fmt.Printf("v2_p: %p\n", &user) //0xc0000a4030
	user.Name = "test_v2"
}

func main() {
	u := User{Name: "init"}

	up := &u
	fmt.Printf("init: %p \n", up) //0xc0000a4018
	setNameV1(up)
	setNameV2(u)
}

type User struct {
	Name string
	Age  int
}

func main() {
	userList := []User {
		User{Name: "aa", Age: 1},
		User{Name: "bb", Age: 1},
	}

	var newUser []*User
	for _, u := range userList {
		newUser = append(newUser, &u)
	}

	// 第一次：bb
	// 第二次：bb
	for _, nu := range newUser {
		fmt.Printf("%+v", nu.Name)
	}
}

func main() {
	userList := []User {
		User{Name: "aa", Age: 1},
		User{Name: "bb", Age: 1},
	}

	var newUser []*User
	for _, u := range userList {
		fmt.Printf("point: %p\n", &u)
		fmt.Printf("val: %s\n", u.Name)
		newUser = append(newUser, &u)
	}
}

// 最终输出结果如下：
point: 0xc00000c030
val: aa
point: 0xc00000c030
val: bb

// 这里要注意下，理论上这里都应该输出10的，但有可能出现执行到7或者其他值的时候就输出了，所以实际上这里不完全都输出10
func main() {
	for i := 0; i < 10; i++ {
		go func(idx *int) {
			fmt.Println("go: ", *idx)
		}(&i)
	}
	time.Sleep(5 * time.Second)
}

func incr1(x *int) func() {
	return func() {
		*x = *x + 1   // 这里是一个指针
		fmt.Printf("incr point x = %d\n", *x)
	}
}
func incr2(x int) func() {
	return func() {
		x = x + 1
		fmt.Printf("incr normal x = %d\n", x)
	}
}

func main() {
	x := 1
	i1 := incr1(&x)
	i2 := incr2(x)
	i1() // point x = 2
	i2() // normal x = 2
	i1() // point x = 3
	i2() // normal x = 3

	x = 100
	i1() // point x = 101  // 闭包1的指针变量受外部影响，被重置为100，并继续递增
	i2() // normal x = 4
	i1() // point x = 102
	i2() // normal x = 5
}

type Escape struct {
	Num1  int
	Str1  *string
	Slice []int
}

// 返回局部变量的指针
func NewEscape() *Escape {
	return &Escape{}   // &Escape{} escapes to heap
}

func main() {
	e := &Escape{Num1: 0}
}

func main() {
	e := NewEscape()
	e.SetNum1(10)

	name := "aa"
	// e.Str1 中，e是已经逃逸的变量， &name是被引用的指针
	e.Str1 = &name  // moved to heap: name
}

func main() {
	e := NewEscape()
	e.SetNum1(10)

	name := "aa"
	e.Str1 = &name

	// 指针类型的slice
	arr := make([]*int, 2) 
	n := 10  // moved to heap: n
	arr[0] = &n // 被引用的指针
}