Question

让我说我有这样的事情：

var x: Int = 6
var y: Float = 11.5

所以，结果必须像这样写

var result = Float(x) * y

或

var result = x * Int(y)

这是有道理的，对吗？
但是，我认为有点笨拙，所以我试图为此制作一些自定义操作符：

infix operator *~ { associativity left precedence 150 } //floating

func *~ (lhs: Float, rhs: Int) -> Float {
    return lhs * Float(rhs)
}

func *~ (lhs: Int, rhs: Float) -> Float {
    return rhs * Float(lhs)
}


infix operator *| { associativity left precedence 150 } //Integer

func *| (lhs: Float, rhs: Int) -> Int {
    return Int(lhs) * rhs
}

func *| (lhs: Int, rhs: Float) -> Int {
    return Int(rhs) * lhs
}

它有效，但它们太多了，所以我试图为这些功能制作通用版本。到目前为止我的尝试：

func *~ <T: FloatingPointType, V:IntegerType>(lhs: T, rhs: V) -> T {
    return lhs * T(rhs) 
    // error:
    // Could not find an overload for 'init' that accepts the supplied arguments
}

有人可以帮忙吗？谢谢。

Answer 1

protocol Fraction {
    init(_ value: Double)
    var asDouble: Double { get }
}

extension Int     : Fraction { var asDouble : Double { return Double(self) } }
extension Double  : Fraction { var asDouble : Double { return self         } }
extension Float   : Fraction { var asDouble : Double { return Double(self) } }
extension CGFloat : Fraction { var asDouble : Double { return Double(self) } }

infix operator ** { associativity left precedence 170 }

func **(lhs:Int, rhs:Int) -> Int {
    return lhs * rhs
}
func **<T:Fraction, U:Fraction>(lhs:T, rhs:U) -> Double {
    return lhs.asDouble * rhs.asDouble

}

2 ** 2     // 4
2 ** 2.2   // 4.4
2.5 ** 2   //  5.0
2.2 ** 2.2 // 4.84

Answer 2

你所做的不仅仅是适得其反。

你所谓的笨拙是阻止一个最大的错误来源。因此，您希望投入大量时间并努力撤消此操作，并使您的源代码在此过程中无法读取。

任何人掌握你的源代码都会花费数小时来撤消你的工作并将所有内容变成普通的Swift代码。

使用自定义运算符覆盖类型转换

2 个答案: