Go语言中模拟运算符作为变量：函数、映射与反射的应用

var o Operator // Go中不存在Operator类型
o = +          // 运算符不能作为右值

package main

import "fmt"

// 定义一个函数类型，表示接受两个int参数并返回一个int结果的函数
type BinaryOperation func(int, int) int

// 实现具体的加法操作
func Add(a, b int) int {
    return a + b
}

// 实现具体的减法操作
func Subtract(a, b int) int {
    return a - b
}

// 实现具体的乘法操作
func Multiply(a, b int) int {
    return a * b
}

// 实现具体的除法操作
func Divide(a, b int) int {
    if b == 0 {
        fmt.Println("Error: Division by zero!")
        return 0 // 或者返回一个错误
    }
    return a / b
}

// 运算执行函数，接受两个操作数和一个BinaryOperation函数
func DoOperation(a, b int, op BinaryOperation) int {
    return op(a, b)
}

func main() {
    // 将函数赋值给变量
    var op1 BinaryOperation = Add
    var op2 BinaryOperation = Divide

    fmt.Printf("10 + 5 = %d\n", DoOperation(10, 5, op1))
    fmt.Printf("10 / 5 = %d\n", DoOperation(10, 5, op2))

    // 也可以直接传递匿名函数
    fmt.Printf("10 * 5 = %d\n", DoOperation(10, 5, func(x, y int) int { return x * y }))

    // 或者直接使用具名函数
    fmt.Printf("10 - 5 = %d\n", DoOperation(10, 5, Subtract))
}

package main

import "fmt"

// 定义与上述相同的函数类型和具体操作函数
type BinaryOperation func(int, int) int

func Add(a, b int) int      { return a + b }
func Subtract(a, b int) int { return a - b }
func Multiply(a, b int) int { return a * b }
func Divide(a, b int) int {
    if b == 0 {
        fmt.Println("Error: Division by zero!")
        return 0
    }
    return a / b
}

func main() {
    // 创建一个映射，将字符串运算符映射到对应的函数
    operations := map[string]BinaryOperation{
        "+": Add,
        "-": Subtract,
        "*": Multiply,
        "/": Divide,
    }

    // 根据字符串选择操作并执行
    num1 := 20
    num2 := 4
    operatorSymbol := "/"

    if opFunc, ok := operations[operatorSymbol]; ok {
        result := opFunc(num1, num2)
        fmt.Printf("%d %s %d = %d\n", num1, operatorSymbol, num2, result)
    } else {
        fmt.Printf("Error: Unknown operator '%s'\n", operatorSymbol)
    }

    // 尝试一个不存在的运算符
    operatorSymbol = "%"
    if opFunc, ok := operations[operatorSymbol]; ok {
        result := opFunc(num1, num2)
        fmt.Printf("%d %s %d = %d\n", num1, operatorSymbol, num2, result)
    } else {
        fmt.Printf("Error: Unknown operator '%s'\n", operatorSymbol)
    }
}

package main

import (
    "fmt"
    "reflect"
)

// 假设我们有一些函数，它们有不同的签名
func AddInt(a, b int) int { return a + b }
func ConcatString(s1, s2 string) string { return s1 + s2 }

func main() {
    // 使用map存储函数的反射值
    operations := map[string]reflect.Value{
        "add":    reflect.ValueOf(AddInt),
        "concat": reflect.ValueOf(ConcatString),
    }

    // 调用AddInt
    if op, ok := operations["add"]; ok {
        // 准备参数
        args := []reflect.Value{reflect.ValueOf(10), reflect.ValueOf(5)}
        // 调用函数
        results := op.Call(args)
        fmt.Printf("AddInt(10, 5) = %v\n", results[0].Interface())
    }

    // 调用ConcatString
    if op, ok := operations["concat"]; ok {
        args := []reflect.Value{reflect.ValueOf("Hello, "), reflect.ValueOf("Go!")}
        results := op.Call(args)
        fmt.Printf("ConcatString(\"Hello, \", \"Go!\") = %v\n", results[0].Interface())
    }
}