Question

我是Swift的新手，所以如果我错过了一些痛苦的明显事情，请告诉我。我有一个class，我想按值传递以重载+运算符。

如果我将左参数lhs定义为foo，则该代码将不起作用，但是它是不可变的；如果lhs是inout foo，则该代码将起作用。我已经修改了lhs，但我显然不希望这样做。

我班的快速细分：

class foo<T: Numeric> {
    /* Data */
    /* Init Fn */
    /* += definition */
    static func + (lhs: foo, rhs: foo) -> foo {
        do {
            try lhs += rhs
            return lhs
        } catch {
            /* Error Handling */
        }
    }
}

我来自C ++背景，因此，如果选择的话，我无法按值传递对象，这让我感到惊讶。在问题What are the basic rules and idioms for operator overloading?之后，在C ++中，此重载方法将期望左参数按值传递，而右参数由const &传递，如下所示，但是在这里我似乎没有该选项。

class X {
    /* In Swift operators are not defined internally like this */
    X& operator+=(const X& rhs) {
        // actual addition of rhs to *this
        return *this;
    }
};
inline X operator+(X lhs, const X& rhs) {
    lhs += rhs;
    return lhs;
}

是否有我不知道的方法，或者在Swift中重载的方式有所不同？

任何帮助将不胜感激。

Answer 1

我看不到任何关于可变性的真正问题。请注意，对于类，如果没有按值传递，则只能使用一个运算符来定义另一个。

class Foo<T: Numeric> {
    var value: T

    init(value: T) {
        self.value = value
    }

    static func + (lhs: Foo, rhs: Foo) -> Foo {
        return Foo(value: lhs.value + rhs.value)
    }

    static func += (lhs: Foo, rhs: Foo) {
        lhs.value += rhs.value
    }
}

let ten = Foo<Int>(value: 10)
let eighteen = ten + Foo<Int>(value: 8)
eighteen += Foo<Int>(value: 1)

价值传授

1 个答案: