Go语言中利用接口与反射实现通用数值交换函数

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

func main() {
    x, y := 1, 2
    Swap(x, y)
    fmt.Println(x, y) // 输出仍是 1 2
}

// 错误示例：试图通过 interface{} 直接交换值
func SwapNum(var1, var2 interface{}) {
    // var1 和 var2 仍然是原始值的副本，且不能直接解引用
    // temp := var1
    // var1 = var2
    // var2 = temp
    // 这种赋值只会影响 var1 和 var2 这两个 interface{} 变量本身，
    // 而不会影响它们底层所代表的原始数据。
}

func SwapInt(a, b *int) {
    temp := *a
    *a = *b
    *b = temp
}

func main() {
    x, y := 1, 2
    SwapInt(&x, &y) // 传入变量的地址
    fmt.Println(x, y) // 输出 2 1
}

import (
    "fmt"
    "reflect"
)

// SwapNum 接收两个 interface{} 类型的参数，期望它们是可寻址的指针。
// 该函数利用反射机制交换这两个指针所指向的值。
func SwapNum(a, b interface{}) {
    // 1. 获取 a 和 b 的 reflect.Value
    // reflect.ValueOf(a) 返回一个 reflect.Value 类型的值，它包含了 a 所代表的接口值的运行时信息。
    // .Elem() 方法用于解引用指针。如果 reflect.Value 表示一个指针，Elem() 返回该指针指向的值。
    // 如果 a 或 b 不是指针，或者指向的值不可寻址，Elem() 会导致 panic。
    ra := reflect.ValueOf(a).Elem()
    rb := reflect.ValueOf(b).Elem()

    // 2. 暂存第一个变量的值
    // .Interface() 方法返回 reflect.Value 所代表的值作为 interface{} 类型。
    // 这里我们将 ra（即 *a 的值）转换为 interface{} 类型并暂存。
    tmp := ra.Interface()

    // 3. 将第二个变量的值赋给第一个变量
    // .Set() 方法用于设置 reflect.Value 所代表的变量的值。
    // 它要求传入的 reflect.Value 必须是可设置的（即指向一个可寻址的变量），
    // 并且其类型必须与目标变量的类型兼容。
    ra.Set(rb) // 相当于 *a = *b

    // 4. 将暂存的值赋给第二个变量
    // 由于 tmp 是 interface{} 类型，Set 方法要求参数是 reflect.Value 类型，
    // 因此需要再次通过 reflect.ValueOf() 将 tmp 封装成 reflect.Value。
    rb.Set(reflect.ValueOf(tmp)) // 相当于 *b = tmp_value
}

func main() {
    // 示例1: 交换整数
    a, b := 1, 2
    fmt.Printf("交换前: a=%d, b=%d\n", a, b)
    SwapNum(&a, &b) // 传入 int 变量的指针
    fmt.Printf("交换后: a=%d, b=%d\n", a, b) // 期望输出: a=2, b=1

    fmt.Println("--------------------")

    // 示例2: 交换浮点数
    c, d := 3.5, 5.5
    fmt.Printf("交换前: c=%.1f, d=%.1f\n", c, d)
    SwapNum(&c, &d) // 传入 float64 变量的指针
    fmt.Printf("交换后: c=%.1f, d=%.1f\n", c, d) // 期望输出: c=5.5, d=3.5

    fmt.Println("--------------------")

    // 示例3: 交换字符串
    s1, s2 := "hello", "world"
    fmt.Printf("交换前: s1=%s, s2=%s\n", s1, s2)
    SwapNum(&s1, &s2) // 传入 string 变量的指针
    fmt.Printf("交换后: s1=%s, s2=%s\n", s1, s2) // 期望输出: s1=world, s2=hello
}

// swap 是 MakeFunc 的底层实现，它接收 []reflect.Value 参数，并返回 []reflect.Value。
// 这里的逻辑与 SwapNum 函数的核心交换逻辑相同。
var swap = func(in []reflect.Value) []reflect.Value {
    // 确保传入了两个参数，并且它们都是指针
    if len(in) != 2 || in[0].Kind() != reflect.Ptr || in[1].Kind() != reflect.Ptr {
        panic("swap function expects two pointer arguments")
    }

    ra := in[0].Elem() // 获取第一个指针指向的值
    rb := in[1].Elem() // 获取第二个指针指向的值

    // 确保值是可设置的
    if !ra.CanSet() || !rb.CanSet() {
        panic("cannot set values of provided arguments")
    }

    // 执行交换
    tmp := ra.Interface()
    ra.Set(rb)
    rb.Set(reflect.ValueOf(tmp))

    return nil // 函数没有返回值
}

// makeSwap 接收一个函数指针 fptr，并为其动态创建一个具有相同签名但由反射实现的函数。
func makeSwap(fptr interface{}) {
    // 1. 获取 fptr 的 reflect.Value，并解引用以获取其底层函数指针本身
    fn := reflect.ValueOf(fptr).Elem()

    // 2. 使用 reflect.MakeFunc 创建一个新的 reflect.Value，它表示一个函数。
    //    fn.Type() 获取函数指针的类型（即函数签名）。
    //    swap 是实际执行逻辑的函数。
    v := reflect.MakeFunc(fn.Type(), swap)

    // 3. 将新创建的函数赋值给原始的函数指针
    fn.Set(v)
}

func main() {
    // 声明一个 int 类型交换函数的变量
    var intSwap func(*int, *int)
    a, b := 1, 0

    // 动态创建 intSwap 函数的实现
    makeSwap(&intSwap) 

    fmt.Printf("交换前: a=%d, b=%d\n", a, b)
    intSwap(&a, &b) // 调用 intSwap，编译器会检查参数类型
    fmt.Printf("交换后: a=%d, b=%d\n", a, b) // 期望输出: a=0, b=1

    fmt.Println("--------------------")

    // 声明一个 string 类型交换函数的变量
    var stringSwap func(*string, *string)
    s1, s2 := "Go", "Lang"
    makeSwap(&stringSwap)

    fmt.Printf("交换前: s1=%s, s2=%s\n", s1, s2)
    stringSwap(&s1, &s2)
    fmt.Printf("交换后: s1=%s, s2=%s