Go语言中实现泛型加法：使用reflect包处理动态类型

func AddInt(val1, val2 int) int {
    return val1 + val2
}

// 错误示例：无法直接对 interface{} 进行加法
/*
func AddGenericFail(val1, val2 interface{}) interface{} {
    // 编译错误：+ 运算符未定义在 interface{} 上
    // return val1 + val2
}
*/

import (
    "fmt"
    "reflect"
)

func AddAttempt(val1, val2 interface{}) {
    type_val1 := reflect.TypeOf(val1)
    type_val2 := reflect.TypeOf(val2)
    fmt.Println(type_val1, type_val2) // 输出如：int int

    // 错误：type_val1 是一个 reflect.Type 类型的值，而不是一个Go语言的类型字面量
    // result1 := val1.(type_val1)
    // result2 := val2.(type_val2)
}

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("类型不匹配，无法相加：%v 和 %v", value_a.Kind(), value_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, reflect.Uintptr: // 包括 uintptr
        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("Error:", err1)
    } else {
        fmt.Printf("10 + 20 = %v (Type: %T)\n", res1, res1) // 输出：10 + 20 = 30 (Type: int64)
    }

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

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

    // 无符号整型加法
    var u1, u2 uint = 100, 200
    res4, err4 := Add(u1, u2)
    if err4 != nil {
        fmt.Println("Error:", err4)
    } else {
        fmt.Printf("%d + %d = %v (Type: %T)\n", u1, u2, res4, res4) // 输出：100 + 200 = 300 (Type: uint64)
    }

    // 类型不匹配示例
    res5, err5 := Add(10, 3.14)
    if err5 != nil {
        fmt.Println("Error:", err5) // 输出：Error: 类型不匹配，无法相加：int64 和 float64
    }

    // 不支持的类型示例 (例如，布尔值)
    res6, err6 := Add(true, false)
    if err6 != nil {
        fmt.Println("Error:", err6) // 输出：Error: 不支持该类型（bool）的加法操作
    }
}

package main

import "fmt"

// Number 接口定义了所有支持加法的数值类型
type Number interface {
    int | int8 | int16 | int32 | int64 |
        uint | uint8 | uint16 | uint32 | uint64 | uintptr |
        float32 | float64 |
        complex64 | complex128
}

// AddGeneric 是一个泛型函数，可以对任何满足 Number 接口的类型进行加法
func AddGeneric[T Number](a, b T) T {
    return a + b
}

func main() {
    fmt.Println(AddGeneric(1, 2))         // int
    fmt.Println(AddGeneric(1.5, 2.5))     // float64
    fmt.Println(AddGeneric(uint(10), uint(20))) // uint
    // fmt.Println(AddGeneric("hello", "world")) // 编译错误：string 不满足 Number 接口
}