Arrays 深度复制数组，其中元素是自定义类的可选元素

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

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

对于自定义类对象的深度副本，我实现了以下协议：

protocol Copyable {
    init(instance: Self)
}

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

现在我还有需要深度复制的自定义类对象数组。为了实现这一点，我为

数组

编写了一个扩展，其中元素是

可复制的

，它如下所示，并且正在工作：

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

现在，我的第二个自定义类包含两个

MySimpleObject

数组（1个数组中的元素

MySimpleObject

是非可选的，1个数组中的元素

MySimpleObject

是可选的。此类如下所示：

class MySimpleObject: Copyable {

    let myString: String

    init() {
        self.myString = ""
    }

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

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

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

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

有人能告诉我我需要的方向吗？我们如何以正确的方式实现这一点

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

致以最良好的祝愿

---

Teetz

似乎您对可选元素的数组扩展有一点不正确的假设。您正在对未声明的可选元素调用

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
        }
    }
}

extension可选：可复制，包装：可复制{
init（实例：可选）{
如果let instance=instance{
self=可选（instance.copy（））
}否则{
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()
    }
}

协议可复制{
init（实例：Self）
}
扩展可复制{
func copy（）->Self{
返回Self.init（实例：Self）
}
}
扩展名可选：可复制，其中已包装：可复制{
init（实例：可选）{
如果let instance=instance{
self=可选（instance.copy（））
}否则{
self=nil
}
}
}
扩展数组，其中元素：可复制{
func clone（）->[元素]{
var copiedaray=[Element]（）
自我元素{
copiedArray.append（element.copy（））
}
返回副本阵列
}
}
类MySimpleObject:可复制{
让我的字符串：字符串
init（）{
self.myString=“”
}
必需的初始化（实例：MySimpleObject）{
self.myString=instance.myString
}
}
类MyObject:可复制{
var myArray=[MySimpleObject]（）
var myArrayWithOptionals=[MySimpleObject？]（）
必需的初始化（实例：MyObject）{
self.myArray=instance.myArray.clone（）
self.myArrayWithOptionals=instance.myArrayWithOptionals.clone（）
}
}

谢谢@Sandeep。这正是我所需要的。工作得很有魅力！

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()
    }
}