Go 语言泛型求和：利用反射与类型参数实现通用加法操作

func AddInt(val1, val2 interface{}) int {
    new_a := val1.(int) // 明确指定为int类型
    new_b := val2.(int) // 明确指定为int类型
    return new_a + new_b
}

package main

import (
    "fmt"
    "reflect"
)

// Add 函数通过反射实现泛型加法，支持数值类型和字符串
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("类型不一致，无法相加: %v (%v) 和 %v (%v)", value_a.Kind(), a, value_b.Kind(), b)
    }

    // 根据值的Kind执行不同的加法操作
    switch value_a.Kind() {
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        return value_a.Int() + value_b.Int(), nil
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
        return value_a.Uint() + value_b.Uint(), nil
    case reflect.Float32, reflect.Float64:
        return value_a.Float() + value_b.Float(), nil
    case reflect.String:
        return value_a.String() + value_b.String(), nil
    default:
        return nil, fmt.Errorf("不支持的类型 %v 无法执行加法", value_a.Kind())
    }
}

func main() {
    // 整数加法
    res1, err1 := Add(10, 20)
    if err1 != nil {
        fmt.Println("错误:", err1)
    } else {
        fmt.Printf("10 + 20 = %v (类型: %T)\n", res1, res1) // 输出: 30 (类型: int64)
    }

    // 浮点数加法
    res2, err2 := Add(3.14, 2.86)
    if err2 != nil {
        fmt.Println("错误:", err2)
    } else {
        fmt.Printf("3.14 + 2.86 = %v (类型: %T)\n", res2, res2) // 输出: 6 (类型: float64)
    }

    // 字符串连接
    res3, err3 := Add("Hello, ", "Go!")
    if err3 != nil {
        fmt.Println("错误:", err3)
    } else {
        fmt.Printf("\"Hello, \" + \"Go!\" = %v (类型: %T)\n", res3, res3) // 输出: Hello, Go! (类型: string)
    }

    // 类型不匹配的错误示例
    _, err4 := Add(1, 2.5)
    if err4 != nil {
        fmt.Println("错误:", err4) // 输出: 错误: 类型不一致，无法相加: int (1) 和 float64 (2.5)
    }

    // 不支持的类型示例
    _, err5 := Add(true, false)
    if err5 != nil {
        fmt.Println("错误:", err5) // 输出: 错误: 不支持的类型 bool 无法执行加法
    }
}

package main

import (
    "fmt"
    "golang.org/x/exp/constraints" // Go 1.18+ 引入，Go 1.21+ 可直接使用 cmp 包中的 Ordered
)

// GenericAdd 函数使用类型参数实现泛型加法
// T 是一个类型参数，约束为 constraints.Ordered，表示T必须是可排序的类型
func GenericAdd[T constraints.Ordered](a, b T) T {
    return a + b
}

func main() {
    // 整数加法
    fmt.Printf("10 + 20 = %v (类型: %T)\n", GenericAdd(10, 20), GenericAdd(10, 20))

    // 浮点数加法
    fmt.Printf("3.14 + 2.86 = %v (类型: %T)\n", GenericAdd(3.14, 2.86), GenericAdd(3.14, 2.86))

    // 字符串连接
    fmt.Printf("\"Hello, \" + \"Go!\" = %v (类型: %T)\n", GenericAdd("Hello, ", "Go!"), GenericAdd("Hello, ", "Go!"))

    // 类型不匹配会在编译时报错
    // GenericAdd(1, 2.5) // 编译错误: 1 (int) does not satisfy constraints.Ordered (type float64)
    // GenericAdd("test", 1) // 编译错误: "test" (string) does not satisfy constraints.Ordered (type int)
}