Question

 protocol ParentProtocol { }

 protocol ChildProtocol: ParentProtocol { }

 protocol Child_With_Value_Protocol: ParentProtocol {
     associatedType Value

     func retrieveValue() -> Value
 }

尝试创建包含 ParentProtocol和ChildProtocol的{strong} Child_With_Value_Protocol类型的单个数组。有没有办法创建一个遍历异构数组的函数并返回仅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时不知道类型，因此错误Child_With_Value_Protocol会失败，这会导致下一个失败的解决方案。

尝试失败的解决方案＃2

如果数组是仅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

修改type-erase结构以包含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)? }

Answer 1

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

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

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]

虽然我确信可以改进，但认为符合原始意图。否？

协议类型的异构混合，包括通用协议

尝试失败的解决方案＃1

尝试失败的解决方案＃2

尝试失败的解决方案＃3

尝试失败的解决方案＃4

1 个答案: