PtrSwap不仅仅是原地交换两个数

PtrSwap不仅仅是原地交换两个数

交换两个数，实际上是交换两个数的地址

交换两个int数

package main

import "fmt"

func Swap(a, b *int) {
	tmp := *a
	*a = *b
	*b = tmp
}

func main() {
	num1 := 1
	num2 := 2
	fmt.Println(fmt.Sprintf("num1此时结果为:%d, num2此时结果:为%d", num1, num2))
	Swap(&num1, &num2)
	fmt.Println(fmt.Sprintf("交换后, num1此时结果为:%d, num2此时结果:为%d", num1, num2))
}

# 输出
num1此时结果为:1, num2此时结果:为2
交换后, num1此时结果为:2, num2此时结果:为1

接受任意相同类型

首先，我们想到的就是interface作为swap()里面形参，那么就用类型断言来实现类型判断

package main

import (
	"fmt"
)

func Swap(a , b interface{}) {
	switch a.(type) {
	case *int:
		a2 := a.(*int)
		b2 := b.(*int)
		tmp := *a2
		*a2 = *b2
		*b2 = tmp
	case *float64:
		a2 := a.(*float64)
		b2 := b.(*float64)
		tmp := *a2
		*a2 = *b2
		*b2 = tmp
	case *float32:
		a2 := a.(*float32)
		b2 := b.(*float32)
		tmp := *a2
		*a2 = *b2
		*b2 = tmp
	case *interface{}:
		a2 := a.(*interface{})
		b2 := b.(*interface{})
		tmp := *a2
		*a2 = *b2
		*b2 = tmp
	case *string:
		a2 := a.(*string)
		b2 := b.(*string)
		tmp := *a2
		*a2 = *b2
		*b2 = tmp
	}
}


func main() {
	num1 := 1
	num2 := 2
	Swap(&num1, &num2)
	fmt.Println(num1)
	fmt.Println(num2)
}

# 输出
2
1

缺点

可以看见，类型判断是如此的繁琐，那么用啥来优化呢？很遗憾的是，至今都没找到答案

反射的坑

我最初想的是反射的出来的数据类型直接用

// 以下是我天真想的错误示范
func R(a interface{}) {
	rd := reflect.ValueOf(a).Kind()
	r := a.(rd)
	fmt.Println(r)
}

// 结果报错： rd (type reflect.Type) is not a type

反射可以得出数值的类型，也就是reflect.Kind()，但是，文档里面的基本数字类型的type != reflect.Type,因为反射的Type基本单位是uint，所以还是只能进行一大堆的判断，那就和断言差不多了