我该如何在Objective-C中进行深拷贝？

Question

我正在学习iOS开发，对Objective-C中的深拷贝感到困惑。比如说，我有以下三个类。现在我想要对ClassA进行深拷贝，有谁可以教我如何完成复制方法？

A:

@interface ClassA : NSObject <NSCopying>

@property (nonatomic, assign) int aInt;
@property (nonatomic, retain) ClassB *bClass;

@end

B：

@interface ClassB : NSObject <NSCopying>

@property (nonatomic, assign) int bInt;
@property (nonatomic, retain) ClassC *cClass;

@end

C：

@interface ClassC : NSObject <NSCopying>

@property (nonatomic, assign) int cInt;
@property (nonatomic, copy) NSString *str;

@end

- Fantasy

---

您还没有展示copy方法的开头... - Wain

Answer 1

在http://www.techotopia.com/index.php/Copying_Objects_in_Objective-C的解释中提到:

"这可以通过将对象及其组成元素写入档案文件，然后读取回新对象来实现。"

@implementation ClassA

- (id)copyWithZone:(NSZone*)zone{
    NSData *buffer;
    buffer = [NSKeyedArchiver archivedDataWithRootObject:self];
    ClassA *copy = [NSKeyedUnarchiver unarchiveObjectWithData: buffer];
    return copy;
}
@end

- cohen72

---

真正的深度复制方法 :) - Julian

在ClassA中，所有自定义对象都必须实现NSCoding协议吗？ - productioncoder

但是这样做会将所有数据都复制两遍，如果对象很大的话代价相对较高，不是吗？ - GreenAsJade

@GreenAsJade 这是一个很好的问题 - 我不确定，但如果你找到了答案，请告诉我。 - cohen72

这是一个非常出色的解决方案，值得更多的赞赏。 - Albert Renshaw

Answer 2

在每个你想要可复制的类中，你应该添加copyWithZone:方法。

NB：我手写的，请注意错别字。

-(id) copyWithZone:(NSZone *) zone
{
    ClassA *object = [super copyWithZone:zone];
    object.aInt = self.aInt;
    object.bClass = [self.bClass copyWithZone:zone];
    return object;
}

-(id) copyWithZone:(NSZone *) zone
{
    ClassB *object = [super copyWithZone:zone];
    object.bInt = self.bInt;
    object.cClass = [self.cClass copyWithZone:zone];
    return object;
}

-(id) copyWithZone:(NSZone *) zone
{
    ClassC *object = [super copyWithZone:zone];
    object.cInt = self.cInt;
    object.str = [self.str copy];
    return object;
}

- James Webster

---

你的实现中不想调用 super 吗？ - Wain

我不确定 :P 但是一些研究告诉我编辑是更安全的方式。请参考这个答案。 - James Webster

那会有所帮助。但是如果超类有任何属性，您目前可能会遗漏它们。 - Wain

它们是不同的实例，因此没有递归。每个实例只需沿着类层次结构工作，确保将实例中的所有实例变量复制。 - Wain

我认输了。你说得很有道理。 :) - James Webster

Answer 3

iOS上的Objective-C没有提供任何直接的语言或库构造来在浅拷贝和深拷贝之间切换。每个类都定义了“获取其副本”的含义：

@implementation ClassA

- (id) copyWithZone: (NSZone*) zone
{
    ClassA *copy = [super copyWithZone:zone];
    [copy setBClass:bClass]; // this would be a shallow copy
    [copy setBClass:[bClass copy]]; // this would be a deep copy
    return copy;
}

@end

当然，在ClassB和ClassC中你也需要做出相同的决定。如果我没错的话，Objective-C中复制的通常语义是返回浅复制。更多有关这个主题的讨论，请参见有关复制数组的这个问题。

- zoul

---

确实没有语言说明符或内置方法来进行复制或深度复制，这是一件遗憾的事情。理论上，不可变对象不会被复制，只会增加引用计数，因为内容不能更改，所以您可能只需仅复制引用，并仅对可变对象进行深层复制。不幸的是，没有定义NSMutableObject，可变对象的命名只是由个人自行决定。 - isgoed

@isgoed 在Objective-C中，许多东西并不是由特定的语言特性强制执行的 - 现代功能的大部分期望是由Foundation建立的标准和最佳实践，而不是编译器强制执行的规则。它是一种古老的语言，更多意图是在运行时由库/框架/应用程序代码处理（就像Smalltalk），这使得它在某些方面更加笨重，但也使得它易于完成在更严格的现代语言中几乎不可能的事情。对于它所拥有的东西来说，它是一种很棒的语言，而不是因为它没有的东西。 - Slipp D. Thompson

Answer 4

我有一些自定义类，其中包含长列表的属性，因此我对它们进行了迭代：

@interface MyClass : NSObject <NSCopying>

#import <objc/runtime.h>

-(id) copyWithZone: (NSZone *) zone {

    MyClass *myCopy = [[MyClass alloc] init];

    //deepCopy
    unsigned int numOfProperties;
    objc_property_t *properties = class_copyPropertyList([self class], &numOfProperties);

    for (int i = 0; i < numOfProperties; i++) {

       objc_property_t property = properties[i];
       NSString *propertyName = [[NSString alloc]initWithCString:property_getName(property) encoding:NSUTF8StringEncoding];
       [adressCopy setValue:[[self valueForKey:propertyName] copy] forKey:propertyName];
    }
    return myCopy;
}

所有 customClassProperties 也需要实现这个方法。

- Yedy

---

这将仅复制属性（使用@property定义的所有内容），而不是成员值（在{}之间定义的所有内容）。这是initAsCopy例程的有用修正（我不使用copy（WithZone），因为它是虚假的，请参见我的答案）。如果这是一个类别，那就更好了。但由于这不是问题的答案，我会对其进行投票（它不能完全复制）。此外：

• adressCopy未声明。你的意思是myCopy。
• 你没有释放属性
• 在释放之前应该检查属性是否为nil。
• #import <objc/runtime.h>不能放在那里。

- isgoed

Answer 5

这可能会有所帮助。该链接展示了如何使用NSKeyedArchiver进行深拷贝。

http://iphonecodecenter.wordpress.com/2013/08/26/difference-between-shallow-copy-and-deep-copy/

- Easwaramoorthy K

Answer 6

Objective-C的copy和copyWithZone规范是虚假和危险的，不应该使用。 --!-- 至少在使用ARC（自动引用计数）时不应该使用（2016-08-23）--!-- 该代码将导致写出内存边界/缓冲区溢出。 相反，我提供了一种安全复制对象的方法initAsShallowCopy和deepCopy。

请参见下面代码中的我的测试结果：

#import <Foundation/Foundation.h>

@interface ClassA : NSObject
{
    @public
    NSMutableString*    A_Name;
    NSInteger           A_NSInteger;
    long int            A_int;
    float               A_float;
}
    -(id)init;
    -(id)copyWithZone:(NSZone *) zone;      // DON'T USE copy OR copyWithZone, unless you ignore Apple's guidelines and always make shallow copies in line with the correct example code here for initAsShallowCopy (but you return a copy instead of being a copy)
    -(id)initAsShallowCopy:(ClassA *)original;  // Correct way to make a shallow copy
    -(void)deepCopy;                            // Correct way to make a deep copy (Call initAsShallowCopy first)
@end

@interface ClassB : ClassA
{
    @public
    NSMutableString*    B_Name;
    NSInteger           B_NSInteger;
    long int            B_int;
    float               B_float;
}
    -(id)init;
    -(id)copyWithZone:(NSZone *) zone;      // DON'T USE copy OR copyWithZone, unless you ignore Apple's guidelines and always make shallow copies in line with the correct example code here for initAsShallowCopy (but you return a copy instead of being a copy)
    -(id)initAsShallowCopy:(ClassB *)original;  // Correct way to make a shallow copy
    -(void)deepCopy;                            // Correct way to make a deep copy (Call initAsShallowCopy first)
    -(void)print;
@end

@interface ClassCWithoutCopy : NSObject
{
    @public
    NSMutableString*    C_Name;
    NSInteger           C_NSInteger;
    long int            C_int;
    float               C_float;
}
-(id)init;
-(void)print;

@end

@implementation ClassA


    -(id)init
    {
        if ( self = [super init] ) {    // initialize NSObject
            //A_Name        = [[NSMutableString alloc] init];
            //[A_Name setString:@"I am inited to A"];
            A_Name      = [NSMutableString stringWithString:@"I am inited to A"];
            A_NSInteger = 1;
            A_int       = 1;
            A_float     = 1.0;

            return self;
        }
        return nil;
    }

    /*
    FROM https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSObject_Class/#//apple_ref/occ/instm/NSObject/copy

    -- NSObject Class Reference --


    - (id)copy

    Discussion
    This is a convenience method for classes that adopt the NSCopying protocol. An exception is raised if there is
    no implementation for copyWithZone:.

    NSObject does not itself support the NSCopying protocol. Subclasses must support the protocol and
    implement the copyWithZone: method. A subclass version of the copyWithZone: method should send the message to super first,
    to incorporate its implementation, unless the subclass descends directly from NSObject.


    + copyWithZone:

    Discussion
    This method exists so class objects can be used in situations where you need an object that conforms to the NSCopying protocol.
    For example, this method lets you use a class object as a key to an NSDictionary object.
    You should not override this method.

    CONCLUSION

    copy says we should incorporate the implementation of copyWithZone, while copyWithZone says we should not override it.. So what is it?
    Looking at copyWithZone, we see that it is a class method (+), meaning it has not access to its instantiated members.
    So maybe they mean, we should not override the class method (+), but we should implement its instance method -copyWithZone:
    !!In any case we should not implement copy, because it is just made for convenience by Apple!!

    FROM: https://developer.apple.com/library/tvos/documentation/Cocoa/Reference/Foundation/Protocols/NSCopying_Protocol/index.html

    -- NSCopying --

    Your options for implementing this protocol are as follows:

    1) Implement NSCopying using alloc and init... in classes that don’t inherit copyWithZone:.

    2) Implement NSCopying by invoking the superclass’s copyWithZone: when NSCopying behavior is inherited.
    If the superclass implementation might use the NSCopyObject function, make explicit assignments to
    pointer instance variables for retained objects.

    3) Implement NSCopying by retaining the original instead of creating a new copy when the class and its contents are immutable.

    CONCLUSION:

    From 1) NSObject does not implement copyWithZone so any class that you make that should support copying should call [[Class alloc] init].

    From 2) Any subclass of a copyable object should call [super copyWithZone:zone], but NOT [[Class alloc] init] !!!!!!
    */

    -(id) copyWithZone:(NSZone *) zone
    {
        ClassA *CopiedObject = [[ClassA alloc] init];

        if(CopiedObject){
            CopiedObject->A_Name        = [A_Name copy];
            CopiedObject->A_NSInteger   = A_NSInteger;
            CopiedObject->A_int         = A_int;
            CopiedObject->A_float       = A_float;
            return CopiedObject;
        }
        return nil;
    }

    -(id)initAsShallowCopy:(ClassA *)original   // Correct way to make a shallow copy
    {
        /* Why this has to be done like this:
            It is very annoying to assign every variable explicitely.
            However this has to be done, in order for ARC (Automatic Reference Counting) (2016-08-23) to work.
            The compiler needs to be aware of any reference made to an object or reference cleared to an object in order to keep track of the
            reference counts.
            The danger is that when you add a variable to you class later on, you must not forget to update your initAsShallowCopy function and 
            possibly your DeepCopy function.
            It would be much nicer if you could just do:
            *self = *original;
            But that gives compiler error:
            /DeepCopyTest/main.m:135:9: Cannot assign to class object ('ClassA' invalid)
            So therefore there is also no raw memory copy between objects,
            so we are stuck with writing out each member variable explicitely.
        */
        if ( self = [super init] ) {    // initialize NSObject
            A_Name      = original->A_Name;
            A_NSInteger = original->A_NSInteger;
            A_int       = original->A_int;
            A_float     = original->A_float;
            return self;
        }
        return nil;
    }

    -(void)deepCopy;                            // Correct way to make a deep copy (Call initAsShallowCopy first)
    {
        /*  Luckily now, we only have to duplicate the objects that require a deep copy.
            So we don't have to write out all the floats, ints and NSIntegers, etcetera. Thus only the pointers (*) to objects.
            */
        A_Name  = [A_Name copy];
    }

@end

@implementation ClassB


    -(id)init
    {
        if ( self = [super init] ) {    // initialize ClassA
            B_Name      = [NSMutableString stringWithString:@"I am inited to B"];
            B_NSInteger = 2;
            B_int       = 2;
            B_float     = 2.0;

            return self;
        }
        return nil;
    }

    -(id) copyWithZone:(NSZone *) zone
    {
        //ClassA *CopiedObject = [[ClassA alloc] init]; We are not a direct descendant from NSObject, so don't call alloc-init
        // instead call the super copyWithZone
        ClassB *CopiedObject = [super copyWithZone:zone];   /* Using ARC (Automatic Reference Counting) 2016-08-23:
        THIS IS A MASSIVE BUFFER OVERFLOW/WRITING OUT OF BOUNDS RISK:
        Since super now allocates the object, it will now only allocate an object of size ClassA
        and effectively allocate too little memory for the ClassB. Unless memory allocation is upgraded to work with magic for
        Objective-C, DON'T USE copy or copyWithZone!!!!
        */

        if(CopiedObject){
            CopiedObject->B_Name        = [B_Name copy];
            CopiedObject->B_NSInteger   = B_NSInteger;
            CopiedObject->B_int         = B_int;
            CopiedObject->B_float       = B_float;
            return CopiedObject;
        }
        return nil;
    }

    -(id)initAsShallowCopy:(ClassB *)original   // Correct way to make a shallow copy
    {
        if ( self = [super initAsShallowCopy:original] ) {  // initialize ClassA
            B_Name      = original->B_Name;
            B_NSInteger = original->B_NSInteger;
            B_int       = original->B_int;
            B_float     = original->B_float;
            return self;
        }
        return nil;
    }

    -(void)deepCopy;                            // Correct way to make a deep copy (Call initAsShallowCopy first)
    {
        /*  Luckily now, we only have to duplicate the objects that require a deep copy.
            So we don't have to write out all the floats, ints and NSIntegers, etcetera. Thus only the pointers (*) to objects.
            */
        [super deepCopy];
        B_Name  = [B_Name copy];
    }

    -(void)print
    {
        NSLog(@"A_Name=\"%@\", A_NSInteger=%ld,A_int=%ld,A_float=%f",A_Name,A_NSInteger,A_int,A_float);
        NSLog(@"B_Name=\"%@\", B_NSInteger=%ld,B_int=%ld,B_float=%f",B_Name,B_NSInteger,B_int,B_float);
    }

@end

@implementation ClassCWithoutCopy


    -(id)init
    {
        if ( self = [super init] ) {    // initialize NSObject
            C_Name      = [NSMutableString stringWithString:@"I am inited to C"];
            C_NSInteger = 3;
            C_int       = 3;
            C_float     = 3.0;

            return self;
        }
        return nil;
    }

    -(void)print
    {
        NSLog(@"C_Name=\"%@\", C_NSInteger=%ld,C_int=%ld,C_float=%f",C_Name,C_NSInteger,C_int,C_float);
    }
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {

        ClassB      *OriginalB;
        ClassB      *CopiedB;

    #define USE_CORRECT_DEEP_COPY_AND_SHALLOW_COPY  1
    #define USE_CLASSC_WITHOUT_COPY_TEST    0

    #if(USE_CLASSC_WITHOUT_COPY_TEST)

        ClassCWithoutCopy   *OriginalC;
        ClassCWithoutCopy   *CopiedC;

        OriginalC   = [[ClassCWithoutCopy alloc] init];
        CopiedC     = [OriginalC copy]; /* Thread 1: signal SIGABRT: libc++abi.dylib: terminating with uncaught exception of type NSException
        *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[ClassCWithoutCopy copyWithZone:]: unrecognized selector sent to instance 0x100100450' */
        //CopiedC       = [ClassCWithoutCopy copyWithZone:nil]; /* DeepCopyTest/main.m:283:33: 'copyWithZone:' is unavailable: not available in automatic reference counting mode
        */

        NSLog(@"OriginalC print:1");
        [OriginalC print];
        NSLog(@"CopiedC print:1");
        [CopiedC print];

        [OriginalC->C_Name appendString:@" and Appended as the original"];
        OriginalC->C_NSInteger = 30;
        OriginalC->C_int = 30;
        OriginalC->C_float = 30.0;

        NSLog(@"OriginalC print:2");
        [OriginalC print];
        NSLog(@"CopiedC print:2");
        [CopiedC print];
    #endif

    #if(USE_CORRECT_DEEP_COPY_AND_SHALLOW_COPY)
        OriginalB   = [[ClassB alloc] init];
        CopiedB     = [[ClassB alloc] initAsShallowCopy:OriginalB];

        NSLog(@"OriginalB print:1");
        [OriginalB print];
        NSLog(@"CopiedB print:1");
        [CopiedB print];

        [OriginalB->A_Name appendString:@" and Appended as the original"];
        OriginalB->A_NSInteger = 10;
        OriginalB->A_int = 10;
        OriginalB->A_float = 10.0;
        [OriginalB->B_Name appendString:@" and Appended as the original"];
        OriginalB->B_NSInteger = 20;
        OriginalB->B_int = 20;
        OriginalB->B_float = 20.0;



        NSLog(@"OriginalB print:2");
        [OriginalB print];
        NSLog(@"CopiedB print:2");
        [CopiedB print];
        // This works as expected: The values of OriginalB and CopiedB differ, but the shallow copied strings are the same.

        // Now make a deep copy of CopiedB
        [CopiedB deepCopy];

        [OriginalB->A_Name appendString:@" and Appended twice as the original"];
        OriginalB->A_NSInteger = 100;
        OriginalB->A_int = 100;
        OriginalB->A_float = 100.0;
        [OriginalB->B_Name appendString:@" and Appended twice as the original"];
        OriginalB->B_NSInteger = 200;
        OriginalB->B_int = 200;
        OriginalB->B_float = 200.0;

        NSLog(@"OriginalB print:3");
        [OriginalB print];
        NSLog(@"CopiedB print:3");
        [CopiedB print];
        // This works as expected: The values of OriginalB and CopiedB differ and als the deep copied strings are different.

    #else
        OriginalB   = [[ClassB alloc] init];
        CopiedB     = [OriginalB copy];             // Undefined behaviour. You will write unallocated memory

        NSLog(@"OriginalB print:1");
        [OriginalB print];
        NSLog(@"CopiedB print:1");
        /*[CopiedB print];  / * Thread 1: signal SIGABRT: libc++abi.dylib: terminating with uncaught exception of type NSException
        *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[ClassA print]: unrecognized selector sent to instance 0x10010ad60' */
        NSLog(@"A_Name=\"%@\", A_NSInteger=%ld,A_int=%ld,A_float=%f",CopiedB->A_Name,CopiedB->A_NSInteger,CopiedB->A_int,CopiedB->A_float);
        NSLog(@"B_Name=\"%@\", B_NSInteger=%ld,B_int=%ld,B_float=%f",CopiedB->B_Name,CopiedB->B_NSInteger,CopiedB->B_int,CopiedB->B_float); // Undefined behaviour. You will read unallocated memory


        [OriginalB->A_Name appendString:@" and Appended as the original"];
        OriginalB->A_NSInteger = 10;
        OriginalB->A_int = 10;
        OriginalB->A_float = 10.0;
        [OriginalB->B_Name appendString:@" and Appended as the original"];
        OriginalB->B_NSInteger = 20;
        OriginalB->B_int = 20;
        OriginalB->B_float = 20.0;
        // This at least works: Changing Original, does not alter the values of Copy.


        NSLog(@"OriginalB print:2");
        [OriginalB print];
        NSLog(@"CopiedB print:2");
        NSLog(@"A_Name=\"%@\", A_NSInteger=%ld,A_int=%ld,A_float=%f",CopiedB->A_Name,CopiedB->A_NSInteger,CopiedB->A_int,CopiedB->A_float);
        //NSLog(@"B_Name=\"%@\", B_NSInteger=%ld,B_int=%ld,B_float=%f",CopiedB->B_Name,CopiedB->B_NSInteger,CopiedB->B_int,CopiedB->B_float);   // Undefined behaviour. You will read unallocated memory

        /*[CopiedB->A_Name appendString:@" and Appended as the copy"];  / * Thread 1: signal SIGABRT: libc++abi.dylib: terminating with uncaught exception of type NSException
        *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: 'Attempt to mutate immutable object with appendString:' */
        CopiedB->A_NSInteger = 100;
        CopiedB->A_int = 100;
        CopiedB->A_float = 100.0;
        /*[CopiedB->B_Name appendString:@" and Appended as the copy"];  / * Thread 1: signal SIGABRT: libc++abi.dylib: terminating with uncaught exception of type NSException
         *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: 'Attempt to mutate immutable object with appendString:'*/
        CopiedB->B_NSInteger = 200;                                     // Undefined behaviour. You will write unallocated memory
        CopiedB->B_int = 200;                                           // Undefined behaviour. You will write unallocated memory
        CopiedB->B_float = 200.0;                                       // Undefined behaviour. You will write unallocated memory

        /* Thread 1: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)
        DeepCopyTest(2376,0x7fff7edda310) malloc: *** error for object 0x10010ad98: incorrect checksum for freed object - object was probably modified after being freed.
*** set a breakpoint in malloc_error_break to debug */

        NSLog(@"OriginalB print after modification of CopiedB:");
        [OriginalB print];
        NSLog(@"CopiedB print after modification of CopiedB:");
        /*[CopiedB print];; / * Thread 1: signal SIGABRT: libc++abi.dylib: terminating with uncaught exception of type NSException
        *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[ClassA print]: unrecognized selector sent to instance 0x10010ad60' */

    #endif
    }
    return 0;
}

PS-1: 来自：

https://developer.apple.com/library/mac/documentation/General/Conceptual/DevPedia-CocoaCore/ObjectCopying.html

-- 对象复制 --

深拷贝会复制被引用的对象，而浅拷贝只会复制对这些对象的引用。因此，如果将对象A浅拷贝到对象B，则对象B引用与对象A相同的实例变量（或属性）。特别是对于值对象，深拷贝对象比浅拷贝更可取。

注意：

这个表述不太清楚，尤其是伴随的插图，它给出了错误的解释。

这个表述让人觉得两个指向同一对象的引用算作浅拷贝。这是不正确的。它根本就没有进行拷贝。

明确的表述应该是： -对象的浅拷贝具有从其父对象复制的所有值和引用，但本身在内存中是一个独特的对象。 -对象的深拷贝具有从其父对象复制的所有值，并且本身在内存中也是一个独特的对象，但现在所有的引用都指向它们自己 - 原始引用对象的副本。

尽管深度复制的确切实现可能不会完全产生深度副本。 指向外部引用的对象（例如硬件项目或图形驱动程序）无法复制，但只能增加引用计数。 有些深度复制没有功能意义。一个对象可能引用它所在的窗口，但复制窗口是没有意义的。 一个对象也可能引用被认为是不可变的数据，因此复制它将不是有效的。

PS-2：你本可以在我手动格式化所有代码之前给我ctrl-K的提示。

PS-3：Apple-Z（撤消）会撤消所有我的格式设置而不是最后一次，我无法重做它。

- isgoed

---

为了更好地改进深拷贝：-(void)deepCopy; //正确的深拷贝方式（首先调用initAsShallowCopy） { // A_Name = [A_Name copy]; //这并不是必要的，因为NSString是不可变的，所以复制对象没有任何额外的作用 } - isgoed