Go语言中运算符变量的可行性分析与替代方案

// 这种语法在Go语言中是不支持的
// var o Operator
// o = +
// func DoOperation(a, b int, o Operator) int {
//     return a o b
// }

package main

import "fmt"

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

// DoOperation 函数接受两个整数和一个BinaryOperator类型的函数作为参数
// 它将调用传入的函数来执行具体的运算
func DoOperation(a, b int, op BinaryOperator) int {
    return op(a, b)
}

func main() {
    // 声明并赋值BinaryOperator类型的变量，实际上是函数变量
    var addOp BinaryOperator = func(a, b int) int {
        return a + b
    }

    var subOp BinaryOperator = func(a, b int) int {
        return a - b
    }

    var mulOp BinaryOperator = func(a, b int) int {
        return a * b
    }

    var divOp BinaryOperator = func(a, b int) int {
        if b == 0 {
            panic("division by zero") // 处理除数为零的情况
        }
        return a / b
    }

    // 使用DoOperation函数和不同的操作函数进行计算
    fmt.Printf("10 + 5 = %d\n", DoOperation(10, 5, addOp))
    fmt.Printf("10 - 5 = %d\n", DoOperation(10, 5, subOp))
    fmt.Printf("10 * 5 = %d\n", DoOperation(10, 5, mulOp))
    fmt.Printf("10 / 5 = %d\n", DoOperation(10, 5, divOp))

    // 也可以直接传递匿名函数作为参数
    fmt.Printf("10 %% 3 = %d\n", DoOperation(10, 3, func(a, b int) int {
        return a % b
    }))
}

package main

import "fmt"

// Operator 接口定义了一个执行操作的方法
type Operator interface {
    Apply(a, b int) int
}

// AddOperator 实现了 Operator 接口
type AddOperator struct{}
func (AddOperator) Apply(a, b int) int { return a + b }

// SubtractOperator 实现了 Operator 接口
type SubtractOperator struct{}
func (SubtractOperator) Apply(a, b int) int { return a - b }

// DoOperationWithInterface 接受一个 Operator 接口类型参数
func DoOperationWithInterface(a, b int, op Operator) int {
    return op.Apply(a, b)
}

func main() {
    var addOp Operator = AddOperator{}
    var subOp Operator = SubtractOperator{}

    fmt.Printf("20 + 7 = %d\n", DoOperationWithInterface(20, 7, addOp))
    fmt.Printf("20 - 7 = %d\n", DoOperationWithInterface(20, 7, subOp))
}