我正在快速处理协议(protocol)。我假设它类似于其他语言的“界面”。我正在测试它如何处理变量。协议(protocol)对我来说很新，因为我从未见过与非静态变量的接口(interface)。我创建了一个 Station 协议(protocol)。

protocol Station{
    var id:String {get set}
    var name:String {get set} // station name
    var lines: Array<String> {get set} // all lines persent in this station 
}

然后是包含该站引用的线路。它还包括 Hashable 协议(protocol)。

protocol Line: Hashable  {
    var lineId: String{get set}
    var station1:Station {get set}    // start station
    var station2:Station {get set}   // end station
    var stations:Array<Station> {get set}   // all the stations that is in this line   
}

这是该协议(protocol)的实现

struct LinesImpl: Line{
    var station1: Station
    var station2: Station
    var stations: Array<Station>
    var lineId: String
    static func == (lhs: LinesImpl, rhs: LinesImpl) -> Bool {
        return (lhs.station1.name == rhs.station1.name && lhs.station2.name == rhs.station2.name && lhs.lineId == rhs.lineId)
    }
    func hash(into hasher: inout Hasher) {
        hasher.combine(station1.name)
        hasher.combine(station2.name)
        hasher.combine(lineId)
    }
    init(station1: Station, station2: Station, stations: [Station], lineId: String){
        self.station1 = station1
        self.station2 = station2
        self.stations = stations
        self.lineId = lineId   
    }
}

一旦我添加了 Hashable。我无法再为 Line 协议(protocol)创建引用。

当我尝试这样做时，它说“协议(protocol)‘Line’只能用作通用约束，因为它具有 self 或相关类型要求”:

我在这里看到很多这样的问题，但我仍然看不出错误是什么。任何帮助都是极好的。多谢你们。

最佳答案

当您添加 Hashable 时，即添加了 Equatable，这使它成为具有关联类型 (PAT) 的协议(protocol)，因为 Equatable 是一个 PAT . PAT 不是一种类型；它是一种用于向其他类型添加方法的工具。

您不能将 PAT 用作变量的类型，不能将其放入数组中，不能将其作为参数直接传递，不能将其作为值返回。 PAT 的唯一要点是作为通用约束(where L: Line)。 PAT 说明另一种具体类型必须提供什么才能在某些上下文中可用。

您应该如何解决这个问题尚不清楚。这看起来根本不应该是一个协议(protocol)。这取决于您要在此处解决的代码重用问题。

协议(protocol)通常是关于某些东西可以做什么的。 Line 似乎只是试图隐藏实现，没有表达任何东西；那不是协议(protocol)。如所写，这里根本没有理由使用泛型或协议(protocol)。 Line 的其他实现是什么样的？ (我无法想象您还可能如何实现这种类型。)

我怀疑正确的答案是用 Station 结构和 Line 结构替换所有这些。我没有看到协议(protocol)在哪里发挥作用。

我可以通过以下方式实现您正在构建的内容，以及一些新协议(protocol)以了解它们的用途。其中一些可能超出您解决此问题的需要，但我想展示实际中的协议(protocol)。

// A protocol for "ID" types that automatically gives them handy inits
// Nested ID types mean that Line.ID can't get confused with Station.ID.
// The point of a protocol is to add additional features to a type like this.
protocol IDType: Hashable, ExpressibleByStringLiteral, CustomStringConvertible {
    var value: String { get }
    init(value: String)
}

extension IDType {
    // For convenience
    init(_ value: String) { self.init(value: value) }
    // Default impl for ExpressibleByStringLiteral
    init(stringLiteral value: String) { self.init(value: value) }
    // Default impl for CustomStringConvertible
    var description: String { return value }
}

struct Line: Equatable  {
    struct ID: IDType { let value: String }
    let id: ID
    let stations: [Station]
    var origin: Station { return stations.first! } // We ensure during init that stations is non-empty
    var terminus: Station { return stations.last! }

    init(id: ID, origin: Station, stops: [Station], terminus: Station) {
        self.id = id
        self.stations = [origin] + stops + [terminus]
    }
}

// Conforming Line to this protocol lets it print more beautifully.
extension Line: CustomStringConvertible {
    var description: String { return "\(id): \(origin) -> \(terminus)" }
}

// Stations can't contain Line directly. These are value types, and that would be
// recursive. But this is nice because it lets us construct immutable Stations
// and then glue them together with Lines which may even be in independent
// systems (for example, the bus system might be separate from the rail system,
// but share stations)
struct Station: Hashable {
    struct ID: IDType { let value: String }
    let id: ID
    let name: String

    func lines(in system: System) -> [Line] {
        return system.linesVisiting(station: self)
    }
}

extension Station: CustomStringConvertible {
    var description: String { return name }
}

struct System: Equatable {
    let lines: [Line]

    // Using Set here makes it clear there are no duplicates, and saves
    // some hassle turning it back into an Array, but we could also just
    // return Array here as Array(Set(...))
    var stations: Set<Station> {
        // Uniquify the stations
        return Set(lines.flatMap { $0.stations })
    }

    func linesVisiting(station: Station) -> [Line] {
        return lines.filter { $0.stations.contains(station) }
    }
}

// Some examples of using it.
let stationNames = ["Shady Grove", "Bethesda", "Metro Center", "Glenmont",
                    "Wiehle-Reston East", "Largo Town Center"]

// Build up a few stations; obviously there are many more
let stations = Dictionary(uniqueKeysWithValues:
    stationNames.map { ($0, Station(id: .init($0), name: $0)) })

// Define some lines
let redLine = Line(id: "OR",
                   origin: stations["Shady Grove"]!,
                   stops: [stations["Bethesda"]!, stations["Metro Center"]!],
                   terminus: stations["Glenmont"]!)

let silverLine = Line(id: "SV",
                      origin: stations["Wiehle-Reston East"]!,
                      stops: [stations["Metro Center"]!],
                      terminus: stations["Largo Town Center"]!)

// And glue them together into a system
let system = System(lines: [redLine, silverLine])

关于ios - 协议(protocol) 'Line' 只能用作通用约束，因为它具有 Self 或关联类型要求，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/55066079/