Go语言：操作符作为变量的探讨与函数式模拟实现

package main

import (
    "fmt"
)

// BinaryOperation 定义一个函数类型，表示接受两个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("错误：除数不能为零！")
        return 0 // 或者返回一个错误，这里简化处理
    }
    return a / b
}

// DoOperation 定义一个执行操作的通用函数，它接受两个操作数和一个操作函数
func DoOperation(a, b int, op BinaryOperation) int {
    return op(a, b)
}

func main() {
    // 声明并赋值操作符变量（实际上是函数变量）
    var opAdd BinaryOperation = add
    var opSubtract BinaryOperation = subtract
    var opMultiply BinaryOperation = multiply
    var opDivide BinaryOperation = divide

    // 使用这些函数变量进行操作
    result1 := DoOperation(10, 5, opAdd)
    fmt.Printf("10 + 5 = %d\n", result1)

    result2 := DoOperation(10, 5, opSubtract)
    fmt.Printf("10 - 5 = %d\n", result2)

    result3 := DoOperation(10, 5, opMultiply)
    fmt.Printf("10 * 5 = %d\n", result3)

    result4 := DoOperation(10, 5, opDivide)
    fmt.Printf("10 / 5 = %d\n", result4)

    result5 := DoOperation(10, 0, opDivide) // 尝试除以零
    fmt.Printf("10 / 0 = %d\n", result5)

    // 也可以直接将匿名函数赋值给变量或作为参数传递
    opMod := func(a, b int) int {
        if b == 0 {
            fmt.Println("错误：取模运算除数不能为零！")
            return 0
        }
        return a % b
    }
    result6 := DoOperation(10, 3, opMod)
    fmt.Printf("10 %% 3 = %d\n", result6)
}

package main

import "fmt"

// GenericBinaryOperation 定义一个泛型函数类型
type GenericBinaryOperation[T any] func(T, T) T

// 泛型加法：使用类型约束确保T支持+操作
func genericAdd[T int | float64](a, b T) T {
    return a + b
}

// 泛型乘法：使用类型约束确保T支持*操作
func genericMultiply[T int | float64](a, b T) T {
    return a * b
}

// GenericDoOperation 泛型执行操作函数
func GenericDoOperation[T any](a, b T, op GenericBinaryOperation[T]) T {
    return op(a, b)
}

func main() {
    // 使用泛型操作处理int类型
    var opAddInt GenericBinaryOperation[int] = genericAdd[int]
    fmt.Printf("泛型 int 加法: %d\n", GenericDoOperation(20, 10, opAddInt))

    // 使用泛型操作处理float64类型
    var opAddFloat GenericBinaryOperation[float64] = genericAdd[float64]
    fmt.Printf("泛型 float64 加法: %.2f\n", GenericDoOperation(20.5, 10.3, opAddFloat))

    // 泛型乘法示例
    var opMultiplyInt GenericBinaryOperation[int] = genericMultiply[int]
    fmt.Printf("泛型 int 乘法: %d\n", GenericDoOperation(5, 4, opMultiplyInt))
}