ios - swift 标准库中协议的相关问题

Question

先附上代码：

//自定义结构体类型，进行大小比较
struct Games {
    var winCount: Int
    var loseCount: Int
}

let g1 = Games(winCount: 2, loseCount: 2)
let g2 = Games(winCount: 3, loseCount: 1)

extension Games: Comparable {}  //此协议的实现方法写在外面

//协议方法实现的逻辑由编程者自己定义，要符合常规的逻辑
//<是方法名
func <(b1: Games, b2: Games) -> Bool {
    
    let gScore1 = b1.winCount - b1.loseCount
    let gScore2 = b2.winCount - b2.loseCount
    
    return gScore1 < gScore2
}

g1 < g2

---

跳转过去得到系统标准库中Comparable的协议如下：

public protocol Comparable : Equatable {
    /// A [strict total order](http://en.wikipedia.org/wiki/Total_order#Strict_total_order)
    /// over instances of `Self`.
    @warn_unused_result
    public func <(lhs: Self, rhs: Self) -> Bool
    @warn_unused_result
    public func <=(lhs: Self, rhs: Self) -> Bool
    @warn_unused_result
    public func >=(lhs: Self, rhs: Self) -> Bool
    @warn_unused_result
    public func >(lhs: Self, rhs: Self) -> Bool
}

问题是：
1.swift中协议里面声明的方法不是都需要实现的吗，这里为什么不需要？
2.Comparable协议的方法为什么是在{ }外实现的？

Answer 1

总结一下：

1.实例的比较：判断两个实例值是否相同 Equatable Equatable

Equatable协议：必须实现==方法，根据比较双方的数据类型来选择所对应的==方法。

struct Games {
    var winCount: Int
    var loseCount: Int
}
 
let g1 = Games(winCount: 2, loseCount: 2)
let g2 = Games(winCount: 3, loseCount: 1)
 
//g1 == g2 错误：自定义类型判断是否相等需要遵守协议Equatable，并实现相应方法
 
extension Games: Equatable {}  //此协议只声明了一个方法，方法的实现可以在外面
 
//==为方法名，因为此协议方法是通过==来调用
func ==(b1: Games, b2: Games) -> Bool {
   
    return b1.winCount == b2.winCount && b1.loseCount == b2.loseCount
}

---

2.比较两个实例的大小 Comparable

Equatable协议：必须实现==方法，根据比较双方的数据类型来选择所对应的==方法。

extension Games: Comparable {
 
    //注：对Games数据类型的==方法已经在上面实现，这里可以不用再写。
   
    //协议的实现方法可以写在内部，类型方法在结构体中需要加static
    static func <(b1: Games, b2: Games) -> Bool {
       
        let gScore1 = b1.winCount - b1.loseCount
        let gScore2 = b2.winCount - b2.loseCount
       
        return gScore1 < gScore2
    }
}

---

2.比较两个实例的大小 Comparable

Comparable协议：继承自Equatable必须实现Equatable中的==方法，还必须实现<方法。

public protocol Comparable : Equatable {

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is less than that of the second argument.
    ///
    /// This function is the only requirement of the `Comparable` protocol. The
    /// remainder of the relational operator functions are implemented by the
    /// standard library for any type that conforms to `Comparable`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func <(lhs: Self, rhs: Self) -> Bool

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is less than or equal to that of the second argument.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func <=(lhs: Self, rhs: Self) -> Bool

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is greater than or equal to that of the second argument.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func >=(lhs: Self, rhs: Self) -> Bool

    /// Returns a Boolean value indicating whether the value of the first
    /// argument is greater than that of the second argument.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func >(lhs: Self, rhs: Self) -> Bool
}

3.为什么标准库协议没有在协议中用关键字 @objc optional 表明其它的是可选方法，签署协议后也不用去实现？

#🎜🎜#//库中的Comparable 协议。#🎜🎜# rrreee #🎜🎜#Havthgem 的回答: Swift 静态库对于剩余的对比计算是有默认实现的，基于你自定义的 == 和 <#🎜🎜#

Answer 2

/// Instances of conforming types can be compared using relational
/// operators, which define a [strict total order](http://en.wikipedia.org/wiki/Total_order#Strict_total_order).
///
/// A type conforming to `Comparable` need only supply the `<` and
/// `==` operators; default implementations of `<=`, `>`, `>=`, and
/// `!=` are supplied by the standard library:
///
///     struct Singular : Comparable {}
///     func ==(x: Singular, y: Singular) -> Bool { return true }
///     func <(x: Singular, y: Singular) -> Bool { return false }
///
/// **Axioms**, in addition to those of `Equatable`:
///
/// - `x == y` implies `x <= y`, `x >= y`, `!(x < y)`, and `!(x > y)`
/// - `x < y` implies `x <= y` and `y > x`
/// - `x > y` implies `x >= y` and `y < x`
/// - `x <= y` implies `y >= x`
/// - `x >= y` implies `y <= x`

以上是来自 Comparable 协议的注释，要是还看不懂的话，就回复吧。