Go语言通用加法函数实现：反射与类型断言深度解析

func Add(val1, val2 interface{}) int {
    new_a := val1.(int) // 明确断言为int
    new_b := val2.(int)
    return new_a + new_b
}

package main

import (
    "fmt"
    "reflect"
)

// Add 函数接受两个 interface{} 类型的参数，尝试进行加法运算
// 返回运算结果 (interface{}) 和一个可能的错误 (error)
func Add(a, b interface{}) (interface{}, error) {
    value_a := reflect.ValueOf(a)
    value_b := reflect.ValueOf(b)

    // 检查两个值的底层类型是否一致
    if value_a.Kind() != value_b.Kind() {
        return nil, fmt.Errorf("类型不匹配，无法相加。值1类型: %s, 值2类型: %s", value_a.Kind(), value_b.Kind())
    }

    // 根据值的底层类型进行操作
    switch value_a.Kind() {
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        // 对于整数类型，使用 Int() 方法获取 int64 值并相加
        return value_a.Int() + value_b.Int(), nil
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
        // 对于无符号整数类型，使用 Uint() 方法获取 uint64 值并相加
        return value_a.Uint() + value_b.Uint(), nil
    case reflect.Float32, reflect.Float64:
        // 对于浮点数类型，使用 Float() 方法获取 float64 值并相加
        return value_a.Float() + value_b.Float(), nil
    case reflect.String:
        // 对于字符串类型，使用 String() 方法获取字符串值并进行拼接
        return value_a.String() + value_b.String(), nil
    default:
        // 对于不支持加法运算的类型，返回错误
        return nil, fmt.Errorf("当前类型不支持加法运算：%s", value_a.Kind())
    }
}

func main() {
    // 示例用法
    resInt, err := Add(10, 20)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Printf("10 + 20 = %v (类型: %T)\n", resInt, resInt) // 输出: 30 (类型: int64)
    }

    resFloat, err := Add(3.14, 2.86)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Printf("3.14 + 2.86 = %v (类型: %T)\n", resFloat, resFloat) // 输出: 6 (类型: float64)
    }

    resString, err := Add("Hello, ", "Go!")
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Printf("\"Hello, \" + \"Go!\" = %v (类型: %T)\n", resString, resString) // 输出: Hello, Go! (类型: string)
    }

    // 尝试不同类型相加
    _, err = Add(1, 2.0)
    if err != nil {
        fmt.Println("错误 (类型不匹配):", err) // 输出: 错误 (类型不匹配): 类型不匹配，无法相加。值1类型: int, 值2类型: float64
    }

    // 尝试不支持的类型
    _, err = Add(true, false)
    if err != nil {
        fmt.Println("错误 (不支持的类型):", err) // 输出: 错误 (不支持的类型): 当前类型不支持加法运算：bool
    }
}

package main

import (
    "fmt"
    "reflect"
)

// AddFunc 是一个通用的加法逻辑，由 MakeFunc 包装
func AddFunc(args []reflect.Value) []reflect.Value {
    // 假设 MakeFunc 已经确保了参数类型一致且支持加法
    // 实际实现中可能需要更复杂的类型检查
    val1 := args[0]
    val2 := args[1]

    var result reflect.Value
    switch val1.Kind() {
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        result = reflect.ValueOf(val1.Int() + val2.Int())
    case reflect.Float32, reflect.Float64:
        result = reflect.ValueOf(val1.Float() + val2.Float())
    case reflect.String:
        result = reflect.ValueOf(val1.String() + val2.String())
    default:
        // 这里应处理错误，但在 MakeFunc 场景下，通常假定类型已匹配
        panic(fmt.Sprintf("不支持的类型: %s", val1.Kind()))
    }
    return []reflect.Value{result}
}

// makeFunc 辅助函数，用于创建特定签名的函数
func makeFunc(f func([]reflect.Value) []reflect.Value, ptr interface{}) {
    fn := reflect.ValueOf(ptr).Elem()
    v := reflect.MakeFunc(fn.Type(), f)
    fn.Set(v)
}

func main() {
    // 创建一个 int 类型的加法函数
    var addInt func(int, int) int64
    makeFunc(AddFunc, &addInt)
    fmt.Printf("addInt(1, 1) = %v (类型: %T)\n", addInt(1, 1), addInt(1,1)) // 输出: 2 (类型: int64)

    // 创建一个 float32 类型的加法函数
    var addFloat func(float32, float32) float64
    makeFunc(AddFunc, &addFloat)
    fmt.Printf("addFloat(1.0, 3.1415) = %v (类型: %T)\n", addFloat(1.0, 3.1415), addFloat(1.0, 3.1415)) // 输出: 4.1415 (类型: float64)

    // 创建一个 string 类型的加法函数 (字符串拼接)
    var addString func(string, string) string
    makeFunc(AddFunc, &addString)
    fmt.Printf("addString(\"Go\", \"lang\") = %v (类型: %T)\n", addString("Go", "lang"), addString("Go", "lang")) // 输出: Golang (类型: string)
}

// Go 1.18+ 泛型实现
// type Number interface {
//     int | int8 | int16 | int32 | int64 |
//     uint | uint8 | uint16 | uint32 | uint64 |
//     float32 | float64 |
//     complex64 | complex128
// }

// func GenericAdd[T Number](a, b T) T {
//     return a + b
// }

// func main() {
//     fmt.Println(GenericAdd(10, 20))
//     fmt.Println(GenericAdd(3.14, 2.86))
// }