在“通用where子句”中遇到错误，仍然无法弄清原因！虽然在速成书中是一样的

如何解决在“通用where子句”中遇到错误，仍然无法弄清原因！虽然在速成书中是一样的

主题：通用子句

protocol Container {
    
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}
struct Stack<Element>: Container {
    
    var items = [Element]()
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
 
    mutating func append(_ item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}
func allItemsMatch<C1: Container,C2: Container>
    (_ someContainer: C1,_ anotherContainer: C2) -> Bool
    where C1.Item == C2.Item,C1.Item: Equatable {
        if someContainer.count != anotherContainer.count {
            return false
        }
        for i in 0..<someContainer.count {
            if someContainer[i] != anotherContainer[i] {
                return false
            }
        }
        return true
}
var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
var arrayofstrings = ["uno","dos","tres"]

if-else控制流中出现错误

if allItemsMatch(stackOfStrings,arrayofstrings) {
    print("All items match.")
} else {
    print("Not all items match.")
}

错误说“ arrayofstrings”不符合容器协议。

• 尝试了很多次但无法弄清
• 错误确切地表明-“全局函数'allItemsMatch'要求'[String]'符合'容器'”“

解决方法

正如评论中已经提到的那样，您忘记声明Array符合Container协议。

extension Array: Container { }

与您的问题无关，但您还应该使您的Stack结构也符合Sequence。它将允许您使用Sequence方法elementsEqual

func elementsEqual<OtherSequence>(_ other: OtherSequence) -> Bool where OtherSequence : Sequence,Self.Element == OtherSequence.Element

---

因此只需将index属性添加到您的Stack类型并实现Sequence next属性，如下所示：

struct Stack<Element>: Container {
    typealias Item = Element
    var items = [Item]()
    mutating func push(_ item: Item) { items.append(item) }
    mutating func pop() -> Item { items.removeLast() }
    mutating func append(_ item: Item) { push(item) }
    var count: Int { items.count }
    subscript(i: Int) -> Item { items[i] }
    var index: Int = 0
}

---

extension Stack: Sequence,IteratorProtocol {
    mutating func next() -> Item? {
        guard index < items.endIndex else { return nil }
        defer { index += 1}
        return items[index]
    }
}

---

游乐场测试：

var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
var arrayOfStrings = ["uno","dos","tres"]
stackOfStrings.elementsEqual(arrayOfStrings)  // true