Golang中利用反射实现通用类型安全的值交换教程

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

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

// 错误的尝试：此函数签名要求传入 *interface{} 类型，而非任意类型的指针
// func SwapNumWrong(a *interface{}, b *interface{}) {
//     // ...
// }

// 正确的泛型函数签名，期望 a 和 b 传入的是指向实际变量的指针
func SwapNum(a, b interface{}) {
    // 实际的交换逻辑将在这里实现，需要使用反射
}

package main

import (
    "fmt"
    "reflect"
)

// SwapNum 使用反射来交换两个 interface{} 中所包含的指针指向的值
func SwapNum(a, b interface{}) {
    // 获取 a 和 b 的 reflect.Value 对象
    // 并通过 .Elem() 解引用指针，获取它们所指向的实际值
    ra := reflect.ValueOf(a).Elem()
    rb := reflect.ValueOf(b).Elem()

    // 检查是否为可设置的值 (即是否是可寻址的，并且不是通过非指针传入的)
    if !ra.CanSet() || !rb.CanSet() {
        // 在实际应用中，这里应该返回错误或panic
        fmt.Println("Error: Values are not settable (likely not pointers or not exported fields).")
        return
    }

    // 临时存储 ra 的值
    tmp := ra.Interface()

    // 将 rb 的值赋给 ra
    ra.Set(rb)
    // 将 tmp 的值（即 ra 原始值）赋给 rb
    rb.Set(reflect.ValueOf(tmp)) // 注意：tmp 需要再次包装成 reflect.Value
}

func main() {
    // 示例1: 交换整型
    a := 1
    b := 2
    SwapNum(&a, &b) // 传入指针
    fmt.Println("交换后 (int):", a, b) // 预期输出: 2 1

    // 示例2: 交换浮点型
    c := 3.5
    d := 5.5
    SwapNum(&c, &d) // 传入指针
    fmt.Println("交换后 (float):", c, d) // 预期输出: 5.5 3.5

    // 示例3: 交换字符串
    s1 := "hello"
    s2 := "world"
    SwapNum(&s1, &s2) // 传入指针
    fmt.Println("交换后 (string):", s1, s2) // 预期输出: world hello

    // 注意：如果传入非指针类型，会引发panic (或被上面的 CanSet 检查捕获)
    // var x int = 10
    // var y int = 20
    // SwapNum(x, y) // 错误：会引发 panic，因为 x, y 不是指针
}

package main

import (
    "fmt"
    "reflect"
)

// swap 是一个闭包，实现了通用的交换逻辑。
// 它接收一个 []reflect.Value 切片作为参数，代表了函数的输入参数。
// 它不返回任何值 (返回 nil)。
var swap = func(in []reflect.Value) []reflect.Value {
    // 获取第一个和第二个参数的 reflect.Value，并解引用指针
    ra := in[0].Elem()
    rb := in[1].Elem()

    // 临时存储 ra 的值
    tmp := ra.Interface()

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

    return nil // 交换函数通常不返回显式值
}

// makeSwap 接受一个函数指针 (fptr)，并根据其类型动态创建一个交换函数。
// 例如，如果 fptr 是 *func(*int, *int)，它会创建一个 func(*int, *int) 类型的函数。
func makeSwap(fptr interface{}) {
    // 获取函数指针 fptr 所指向的 reflect.Value
    fn := reflect.ValueOf(fptr).Elem()
    // 使用 reflect.MakeFunc 根据 fn 的类型和 swap 闭包创建新的函数
    v := reflect.MakeFunc(fn.Type(), swap)
    // 将新创建的函数设置给 fn 所指向的函数指针
    fn.Set(v)
}

func main() {
    // 示例1: 创建并使用一个交换 int 类型指针的函数
    var intSwap func(*int, *int) // 定义一个函数变量，其类型是 func(*int, *int)
    makeSwap(&intSwap)           // 动态创建 intSwap 函数

    a, b := 10, 20
    intSwap(&a, &b) // 调用动态创建的 intSwap 函数
    fmt.Println("intSwap 交换后:", a, b) // 预期输出: 20 10

    // 示例2: 创建并使用一个交换 string 类型指针的函数
    var stringSwap func(*string, *string) // 定义一个函数变量，其类型是 func(*string, *string)
    makeSwap(&stringSwap)                 // 动态创建 stringSwap 函数

    s1, s2 := "Go", "Lang"
    stringSwap(&s1, &s2) // 调用动态创建的 stringSwap 函数
    fmt.Println("stringSwap 交换后:", s1, s2) // 预期输出: Lang Go

    // 这种方式在编译时就能检查 intSwap 和 stringSwap 的调用是否符合其签名
    // 例如，intSwap("a", "b") 会在编译时报错
}