Question

我创建了此infix operator ^^作为使用pow函数的替代：

infix operator ^^ { associativity left precedence 155 }
func ^^ <T: IntegerLiteralConvertible>(left: T, right: T) -> T {
    return pow(left as Double, right as Double)
}

我使用IntegerLiteralConvertible协议作为泛型left和right的类型约束，因为根据我的理解this diagramm显示，它基本上包含所有数字类型。

为了使用pow函数，我必须将left和right向下转换为Double，我使用as运算符执行此操作。它不是最安全的方法，但除了这一点之外。

当实现函数this way时，swift告诉我：

<stdin>:4:12: error: cannot invoke 'pow' with an argument list of type '(Double, Double)'
return pow(left as Double, right as Double)
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

据我所知，pow需要两个Double作为参数，为什么会抱怨这个？

Answer 1

感谢@Martin R.这来自我迄今为止在S.O发布的唯一question。

import Cocoa

协议

protocol Fraction { init(_ value:Double) ; var asDouble  : Double { get } }
protocol Text     { init(_ value:String) ; var asString  : String { get } }

扩展

extension String  : Text     { var asString : String { return 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 ^^<T:IntegerType, U:IntegerType> (var base:T, var power:U) -> T {
    if power < 0 { return 0 }
    var result: T = 1
    if power > 0 {
        if power % 2 == 1 { result *= base }
        power /= 2
    }
    while power > 0 {
        base *= base
        if power % 2 == 1 { result *= base }
        power /= 2
    }
    return result
}
func ^^<T:Fraction, U:Fraction> (base: T, power: U) -> T {
    return T(pow(base.asDouble, power.asDouble))
}
func ^^<T:Text, U:IntegerType> (base:T, var power:U) -> T {
    if power  <= 0 { return "" as T }
    if power  == 1 { return base as T }
    return power > 1 ? {var result = ""; for x in 1...power  { result+=base.asString };return result as T}() : "" as T
}
func ^^<T:Text, U:Text> (base:T, var power:U) -> T {
    return "" as T
}

测试

println(1 ^^ -1)               // "0"      Int
println(1 ^^  0)               // "1"      Int
println(1 ^^  1)               // "1"      Int
println(1 ^^  2)               // "1"      Int

println(2 ^^ -1)               // "0"           Int
println(2 ^^  0)               // "1"           Int
println(2 ^^  1)               // "2"           Int
println(2 ^^  2)               // "4"           Int
println(2 ^^  8)               // "256"         Int
println(2 ^^  16)              // "65536"       Int
println(2 ^^  32)              // "4294967296"  Int

println(2 ^^  62)               // "4611686018427387904"

println(UInt(2) ^^ 8)          // "256"      UInt
println(UInt64(2) ^^ 8)        // "256"      UInt64

Answer 2

为什么抱怨这个？

因为pow返回Double。 Double与T不同。错误消息具有误导性，但这意味着“无法找到pow接受(Double, Double)并返回T类型”

我认为你在Swift中误解了“演员”。在Swift as中不会转换数字类型。

let intVal:Int = 12
let doubleVal:Double = intVal as Double
//                            ^ [!] error: 'Int' is not convertible to 'Double'

如果在编译时无法预测操作数的类型，则无效的转换会导致运行时错误：

func foo<T: IntegerLiteralConvertible>(x: T)  {
    x as Double // <-- Execution was interrupted
}
foo(12 as Int)

相反，我们必须明确地“转换”它们。请参阅文档：Numeric Type Conversion

let intVal:Int = 12
let doubleVal:Double = Double(intVal)

这仅适用于Double具有init(_ v: Int)初始值设定项的情况。以下代码无法编译：

func foo<T: IntegerLiteralConvertible>(x: T)  {
    Double(x)
//  ^~~~~~~~~ [!] error: cannot invoke 'init' with an argument of type 'T'
}

由于Double没有init<T:IntegerLiteralConvertible>(_ val:T)初始化程序。

因此，如果您要使用pow()，则必须将T转换为Double以获取参数，并将Double转换为T以返回值。并没有简单的解决方案。

Swift的pow（）函数不接受双打作为参数

2 个答案: