Generics （重新发布）Go中的通用金额

我很抱歉。我不小心删除了我先前的问题。这是我的第二次尝试

我知道Go不支持泛型类型，但应该有一种方法来做到这一点

我试图添加任意类型的两个参数，并使用接口和类型断言返回结果。但我被困在

接口中未定义（+）

想不出我该换哪一种

这是我的上一步

   func Add(val1, val2 interface{}) int {
        new_a := val1.(int)
        new_b := val2.(int)
        return new_a + new_b
   }

这给了我正确的答案，但这是无用的，因为我知道整数值将被传递。我想要一个函数，它不知道将给出什么，并相应地返回给定变量类型的加法

这是我的第二次尝试，我被卡住了

func-Add（val1，val2接口{}）{
//var x接口{}=7//x具有动态类型int和值7
//i:=x.（int）//i具有int类型和值7
//a:=反射值（val1）
//b:=反射值（val2）
//fmt.Println（a，b）
//  
type_val1:=reflect.TypeOf（val1）
type_val2:=reflect.TypeOf（val2）
fmt.Println（类型1，类型2）
result1:=val1。（type_val1）//错误：type_val1不是类型
结果2:=val2。（type_val2）//错误：type_val2不是类型
fmt.Println（结果1，结果2）

在go中没有运算符重载。您不能定义自己的

+

正如您可能已经看到的，在

reflect.Value

上也没有定义方法

Add（）

。 要使用

+

，您必须找到值的基础类型，然后添加它。您可以 通过使用类型断言来实现这一点

根据

+

定义了整数、浮点数、复数值和字符串。 因此，您需要检查该值是否为这些类型之一，将其转换为该类型，然后 然后加上它

例如：

注意，返回类型是

interface{}

，因为可能有不同的返回类型

这可以通过使用

reflect.MakeFunc

（）进行优化：

---

此软件包可以生成大多数切片类型的总和和乘积： 您只需调用

slices.Sum（mySlice）

 func Add(val1, val2 interface{}) {

// var x interface{} = 7  // x has dynamic type int and value 7
// i := x.(int)           // i has type int and value 7

// a := reflect.ValueOf(val1)
// b := reflect.ValueOf(val2)
// fmt.Println(a, b)
// <int Value> <int Value>

type_val1 := reflect.TypeOf(val1)
type_val2 := reflect.TypeOf(val2)
fmt.Println(type_val1, type_val2)

result1 := val1.(type_val1) // ERROR : type_val1 is not a type
result2 := val2.(type_val2) // ERROR : type_val2 is not a type
fmt.Println(result1, result2)

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("Different kinds, can't add them.")
    }

    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("Type does not support addition.")
    }
}

func main() {
    var addInt func(int, int) int64
    var addFloat func(float32, float32) float64

    makeFunc(AddFunc, &addInt)
    makeFunc(AddFunc, &addFloat)

    fmt.Println( addInt(1, 1) )
    fmt.Println( addFloat(1.0, 3.1415) )
}