Go语言中操作符作为变量的可行性分析

// 伪代码，在Go语言中无法编译通过
// var o Operator // 假设存在一个名为Operator的类型
// o = +         // 错误：'+'不是一个可赋值的表达式
//
// func DoOperation(a, b int, o Operator) int {
//     return a o b // 错误：无法直接使用变量作为中缀操作符
// }

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
}

// 执行操作的函数，接收两个操作数和一个BinaryOperation类型的函数作为参数
func DoOperation(a, b int, op BinaryOperation) int {
    return op(a, b)
}

func main() {
    fmt.Println("--- 使用函数类型模拟操作符变量 ---")

    // 将Add函数赋值给BinaryOperation类型的变量
    var currentOp BinaryOperation = Add
    result := DoOperation(10, 5, currentOp)
    fmt.Printf("10 + 5 = %d (使用变量赋值的Add函数)\n", result) // 输出 10 + 5 = 15

    // 将Subtract函数赋值给同一个变量
    currentOp = Subtract
    result = DoOperation(10, 5, currentOp)
    fmt.Printf("10 - 5 = %d (使用变量赋值的Subtract函数)\n", result) // 输出 10 - 5 = 5

    // 直接传递函数字面量（匿名函数）作为操作
    result = DoOperation(10, 5, func(x, y int) int {
        return x / y // 定义一个除法操作
    })
    fmt.Printf("10 / 5 = %d (直接传递匿名函数)\n", result) // 输出 10 / 5 = 2

    // 也可以将所有操作存储在一个map中，通过键来选择操作
    operations := map[string]BinaryOperation{
        "+": Add,
        "-": Subtract,
        "*": Multiply,
        "/": func(x, y int) int {
            if y == 0 {
                fmt.Println("Error: Division by zero!")
                return 0 // 或者panic
            }
            return x / y
        },
    }

    fmt.Println("\n--- 使用map管理操作 ---")
    if opFunc, ok := operations["*"]; ok {
        result = DoOperation(10, 5, opFunc)
        fmt.Printf("10 * 5 = %d (从map中获取操作)\n", result) // 输出 10 * 5 = 50
    }
}

package main

import "fmt"

// 定义一个操作接口
type Operator interface {
    Operate(a, b int) int
}

// 加法操作的实现
type Adder struct{}

func (Adder) Operate(a, b int) int {
    return a + b
}

// 减法操作的实现
type Subtractor struct{}

func (Subtractor) Operate(a, b int) int {
    return a - b
}

// 执行操作的函数，接收Operator接口作为参数
func DoOperationWithInterface(a, b int, op Operator) int {
    return op.Operate(a, b)
}

func main() {
    fmt.Println("\n--- 使用接口模拟操作符变量 ---")

    var addOp Operator = Adder{}
    fmt.Printf("10 + 5 = %d (使用接口实现)\n", DoOperationWithInterface(10, 5, addOp))

    var subOp Operator = Subtractor{}
    fmt.Printf("10 - 5 = %d (使用接口实现)\n", DoOperationWithInterface(10, 5, subOp))
}