首先:我不能在我的场景中使用结构。我知道结构默认是“按值传递”的。但在我的案例中，我确实需要类对象的“按引用传递”语义。

如标题所述，我正在尝试深度复制一个数组，该数组包含自定义类的可选对象。

对于自定义类对象的深拷贝，我实现了以下协议(protocol):

protocol Copyable {
    init(instance: Self)
}

extension Copyable {
    func copy() -> Self {
        return Self.init(instance: self)
    }
}

现在我还有需要深度复制的自定义类对象数组。为了实现这一点，我为 Array 编写了一个扩展，其中 Element 是 Copyable，它看起来像这样并且正在运行:

extension Array where Element: Copyable {
    func clone() -> Array {
        var copiedArray = Array<Element>()
        for element in self {
            copiedArray.append(element.copy())
        }
        return copiedArray
    }
}

假设我有 2 个自定义类。第一个已经符合 Copyable 并且看起来像这样:

class MySimpleObject: Copyable {

    let myString: String

    init() {
        self.myString = ""
    }

    required init(instance: MySimpleObject) {
        self.myString = instance.myString
    }
}

现在我的第二个自定义类包含两个 MySimpleObject 数组(1 个元素为 MySimpleObject 的数组是非可选的，1 个元素为 MySimpleObject 是可选的。这个类看起来像这样:

class MyObject {

    var myArray = [MySimpleObject]()
    var myArrayWithOptionals = [MySimpleObject?]()
}

现在我希望 MyObject 符合 Copyable，这是让我感到困惑的部分。首先，我这样尝试(但这给了我一个错误，如评论中所示:

class MyObject: Copyable {

    var myArray = [MySimpleObject]()
    var myArrayWithOptionals = [MySimpleObject?]()

    required init(instance: MyObject) {
        self.myArray = instance.myArray.clone()
        self.myArrayWithOptionals = instance.myArrayWithOptionals.clone()       // Type 'MySimpleObject?' does not conform to protocol 'Copyable'
    }
}

这个错误对我来说很有意义。因为 MySimpleObject? 不等于 MySimpleObject。

我的第二次尝试是为 Array 编写另一个扩展，但我不确定如何以正确的方式执行此操作:

extension Array where Element == Optional<Copyable> {
    func cloneOptional() -> Array {
        var copiedArray = Array<Element>()
        for element in self {
            copiedArray.append(element?.copy())
        }
        return copiedArray
    }
}

MyObject 看起来像这样: 但我也收到一个错误(再次显示在评论中)

class MyObject: Copyable {

    var myArray = [MySimpleObject]()
    var myArrayWithOptionals = [MySimpleObject?]()

    required init(instance: MyObject) {
        self.myArray = instance.myArray.clone()
        self.myArrayWithOptionals = instance.myArrayWithOptionals.cloneOptional()   // '[MySimpleObject?]' is not convertible to 'Array<Optional<Copyable>>'
    }
}

任何人都可以向我提示我需要的方向吗？我们如何以正确的方式实现它？

如果您需要更多信息，请在评论中告诉我。

最好的问候，

提茨

最佳答案

您似乎对可选元素的数组扩展有一些不正确的假设。您正在对尚未声明的可选对象调用 copy。只需确保 Optional 也符合 Copyable 并且它应该可以在可选数组上使用 clone 正常工作。

extension Optional: Copyable where Wrapped: Copyable {
    init(instance: Optional<Wrapped>) {
        if let instance = instance {
            self = Optional(instance.copy())
        } else {
            self = nil
        }
    }
}

总的来说，你的代码应该是这样的，

protocol Copyable {
    init(instance: Self)
}

extension Copyable {
    func copy() -> Self {
        return Self.init(instance: self)
    }
}

extension Optional: Copyable where Wrapped: Copyable {
    init(instance: Optional<Wrapped>) {
        if let instance = instance {
            self = Optional(instance.copy())
        } else {
            self = nil
        }
    }
}

extension Array where Element: Copyable {
    func clone() -> [Element] {
        var copiedArray = [Element]()
        for element in self {
            copiedArray.append(element.copy())
        }
        return copiedArray
    }
}

class MySimpleObject: Copyable {

    let myString: String

    init() {
        self.myString = ""
    }

    required init(instance: MySimpleObject) {
        self.myString = instance.myString
    }
}

class MyObject: Copyable {

    var myArray = [MySimpleObject]()
    var myArrayWithOptionals = [MySimpleObject?]()

    required init(instance: MyObject) {
        self.myArray = instance.myArray.clone()
        self.myArrayWithOptionals = instance.myArrayWithOptionals.clone()
    }
}

关于arrays - 深度复制数组，其中元素是自定义类的可选，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/51782526/