0 
 protocol ParentProtocol { }

 protocol ChildProtocol: ParentProtocol { }

 protocol Child_With_Value_Protocol: ParentProtocol {
     associatedType Value

     func retrieveValue() -> Value
 }

尝试创建一个ParentProtocol包含和 ChildProtocol的类型数组Child_With_Value_Protocol。有没有可能的方法来创建一个循环遍历异构数组并返回只是 type 的值的函数Child_With_Value_Protocol？

这可能需要架构更改。对所有解决方案开放。

尝试失败的解决方案 #1

var parents: [ParentProtocol] = [...both ChildProtocol & Child_With_Value_Protocol...]

func retrieveValues() -> [Any] {
    var values = [Any]()

    for parent in parents {
        if let childWithValue = parent as? Child_With_Value_Protocol { // Fails to compile
            values.append(childWithValue.retrieveValue())
        }
    }

    return values
}

protocol 'Child_With_Value_Protocol' can only be used as a generic constraint because it has Self or associated type requirements由于编译器在转换为 just 时不知道类型，因此失败并出现错误Child_With_Value_Protocol，这会导致下一个失败的解决方案。

尝试失败的解决方案 #2

如果数组是 just 的同构数组，则Child_With_Value_Protocol可以使用类型擦除来检索值。

var parents: [ParentProtocol] = [...both ChildProtocol & Child_With_Value_Protocol...]

struct AnyValue {
    init<T: Child_With_Value_Protocol>(_ protocol: T) {
        _retrieveValue  = protocol.retrieveValue as () -> Any
    }

    func retrieveValue() -> Any { return _retrieveValue() }

    let _retrieveValue: () -> Any
}

func retrieveValues() -> [Any] {
    var values = [Any]()

    for parent in parents {
        values.append(AnyValue(parent).retrieveValue()) // Fails to compile
    }

    return values
}

由于结构AnyValue没有用于ParentProtocol.

尝试失败的解决方案#3

struct AnyValue {
    init<T: Child_With_Value_Protocol>(_ protocol: T) {
        _retrieveValue  = protocol.retrieveValue as () -> Any
    }

    func retrieveValue() -> Any { return _retrieveValue() }

    let _retrieveValue: () -> Any
}

var erased: [AnyValue] = [AnyValue(...), AnyValue(...), AnyValue(...)]

func retrieveValues() -> [Any] {
    var values = [Any]()

    for value in erased {
        values.append(value.retrieveValue())
    }

    return values
}

与其他解决方案不同，此解决方案实际上可以编译。这个解决方案的问题在于数组erased只能保存类型擦除版本的值Child_With_Value_Protocol。目标是让数组同时保存和 Child_With_Value_Protocol的类型ChildProtocol。

尝试失败的解决方案#4

修改类型擦除结构以包含初始化程序ParentProtocol仍然会创建一个可编译的解决方案，但是该结构将仅使用不太具体的 init，而不是更具体的 init。

struct AnyValue {
    init?<T: ParentProtocol>(_ protocol: T) {
        return nil
    }

    init?<T: Child_With_Value_Protocol>(_ protocol: T) {
        _retrieveValue  = protocol.retrieveValue as () -> Any
    }

    func retrieveValue() -> Any { return _retrieveValue() }

    let _retrieveValue: (() -> Any)?
}
4

1 回答 1

0

之前的评论可能是正确的。不过，您可以将变量装箱在一个枚举中并创建一个数组。然后引用将打开枚举值，每个都有正确类型的关联数据

编辑：我没有打扰相关的值，因为它似乎与所提出的问题无关。以下在操场上工作：

protocol ParentProtocol: CustomStringConvertible {
    static func retrieveValues(parents: [FamilyBox]) -> [ParentProtocol]
}

protocol ChildProtocol: ParentProtocol { }

protocol Other_Child_Protocol: ParentProtocol { }

enum FamilyBox {
    case Parent(parent: ParentProtocol)
    case Child(child: ChildProtocol)
    case OtherChildProtocol(withValue: Other_Child_Protocol)

}


var parents: [FamilyBox] = []

struct P: ParentProtocol {
    var description: String { return "Parent" }

    static func retrieveValues(parents: [FamilyBox]) -> [ParentProtocol] {
        var values = [ParentProtocol]()

        for parent in parents {
            switch parent {
            case .Parent(let elementValue):
                values.append(elementValue)
            default:
                break;
            }
        }
        return values
    }
}

struct C: ChildProtocol {
    var description: String { return "Child" }

    static func retrieveValues(parents: [FamilyBox]) -> [ParentProtocol] {
        var values = [ParentProtocol]()

        for parent in parents {
            switch parent {
            case .Child(let elementValue):
                values.append(elementValue)
            default:
                break;
            }
        }
        return values
    }
}

struct CV: Other_Child_Protocol {
    var description: String { return "Other Child" }

    static func retrieveValues(parents: [FamilyBox]) -> [ParentProtocol] {
        var values = [ParentProtocol]()

        for parent in parents {
            switch parent {
            case .OtherChildProtocol(let elementValue):
                values.append(elementValue)
            default:
                break;
            }
        }
        return values
    }
}

let p = FamilyBox.Parent(parent: P())
let c = FamilyBox.Child(child: C())
let cv = FamilyBox.OtherChildProtocol(withValue: CV())
let array:[FamilyBox] = [p, c, cv]

print(P.retrieveValues(array))
print(C.retrieveValues(array))
print(CV.retrieveValues(array))

最后三行的打印是：

[Parent]
[Child]
[Other Child]

虽然我确信它可以改进，但我认为这符合最初的意图。不？

于 2016-07-03T11:54:00.580 回答