Question

我有2个Swift类的层次结构，需要它们来实现Comparable：

class Thing : Comparable {
    var name = "Thing"
    init(name : String){
        self.name = name
    }
}

class Thingy: Thing {
    override init(name: String){
        super.init(name: "Thingy")

    }  
}
func ==(lhs: Thing, rhs:Thing)->Bool{
    return lhs.name == rhs.name
}

为遵守Comparable，我需要实现此功能：

func <(lhs: Thing, rhs: Thing) -> Bool{
    return lhs.name < rhs.name
}

到目前为止一切顺利，但如果我需要特定的＆lt;用于不同子类型的函数，例如：

func <(lhs: SubThing, rhs: Thing) -> Bool{
        return lhs.name < rhs.name
    }

我该怎么做？编译器似乎忽略了最后一个声明。

如果类型被反转，它也会起作用吗？

lhs: SubThing, rhs: Thing

而不是

lhs: Thing, rhs: SubThing

Answer 1

泛滥救援。使您的Equatable，Comparable函数具有通用性。将T限制为Thing的子类。

func ==<T:Thing>(lhs: T, rhs:T) -> Bool {
    return lhs.name == rhs.name
}


let a = Thing(name: "alpha")
let b = Thingy(name: "beta")

a == b // false

Answer 2

覆盖<运算符应采用最具体的匹配，因此在您的情况下

func <(lhs: Thing, rhs: Thing) -> Bool {
    print("Base");
    return lhs.name < rhs.name
}

func <(lhs: Subthing, rhs: Thing) -> Bool {
    print("Child");
    return lhs.name < rhs.name
}

Subthing(name: "a") < Thing(name: "b")

应该打印Child，但这并不会发生。

使用泛型的重载似乎有效：

func < <T1:Thing, T2: Thing>(lhs: T1, rhs: T2) -> Bool {
    print("Base");
    return lhs.name < rhs.name
}

func < <T1: Subthing, T2: Thing>(lhs: T1, rhs: T2) -> Bool {
    print("Child");
    return lhs.name < rhs.name
}

Subthing(name: "a") < Thing(name: "b")

正确打印Child。

通用重载似乎比基本重载具有更好的类型匹配。

比较Swift类层次结构中的协议

2 个答案: