How to copy an object in Objective-C

Question

I need to deep copy a custom object that has objects of its own. I've been reading around and am a bit confused as to how to inherit NSCopying and how to use NSCopyObject.

Chuppah

The great TUTORIAL for understanding copy, mutableCopy and copyWithZone – Reaper

Answer 1

As always with reference types, there are two notions of "copy". I'm sure you know them, but for completeness.

1. A bitwise copy. In this, we just copy the memory bit for bit - this is what NSCopyObject does. Nearly always, it's not what you want. Objects have internal state, other objects, etc, and often make assumptions that they're the only ones holding references to that data. Bitwise copies break this assumption.
2. A deep, logical copy. In this, we make a copy of the object, but without actually doing it bit by bit - we want an object that behaves the same for all intents and purposes, but isn't (necessarily) a memory-identical clone of the original - the Objective C manual calls such an object "functionally independent" from it's original. Because the mechanisms for making these "intelligent" copies varies from class to class, we ask the objects themselves to perform them. This is the NSCopying protocol.

You want the latter. If this is one of your own objects, you need simply adopt the protocol NSCopying and implement -(id)copyWithZone:(NSZone *)zone. You're free to do whatever you want; though the idea is you make a real copy of yourself and return it. You call copyWithZone on all your fields, to make a deep copy. A simple example is

@interface YourClass : NSObject <NSCopying> 
{
   SomeOtherObject *obj;
}

// In the implementation
-(id)copyWithZone:(NSZone *)zone
{
  // We'll ignore the zone for now
  YourClass *another = [[YourClass alloc] init];
  another.obj = [obj copyWithZone: zone];

  return another;
}

Synonym

But you're making the recipient of the copied object responsible to free it! Shouldn't you autorelease it, or am I missing something here? – Photosynthesis

@bobobobo: No, the fundamental rule of Objective-C memory management is: You take ownership of an object if you create it using a method whose name begins with “alloc” or “new” or contains “copy”. copyWithZone: meets this criteria, therefore it must return an object with a retain count of +1. – Cantoris

@Adam Is there a reason to use alloc instead of allocWithZone: since the zone was passed in? – Mats

Well, zones are effectively unused in modern OS X based runtimes (i.e. I think they're literally never used). But yes, you could call allocWithZone. – Synonym

supposing my 'YourClass' contains 10 more properties, I have to set all of them in my 'copyWithZone' implementation? – Weigle

This works perfect for me, except for if I try to copy an object that has a UIImageView or UIView as a property. Those objects don't have copyWithZone: so I can't do another.img = [img copyWithZone: zone]; and when I use another.img = [img copy]; it doesn't compile, check out this question: #9018444 – Amicable

For completeness, the tutorial for understanding copy, mutableCopy and copyWithZone, linked to in one of the answers, is here. – Expander

Objective-C has no way to make a bitwise (memory) 'shallow'-copy. You are stuck with explicitly assigning each variable in your class. This example also shows why the copy(WithZone) is bogus: How to implement copyWithZone for a subclass of "YourClass". To initialize its member variables it should call its [super copyWithZone], but that calls alloc on its class, which is wrong, because it allocates the wrong object. There is no correct way to implement this. Instead use a solution in the form of initAsShallow copy as I described here. – Auxin

@SebastienPeek Yes, but with the default zone. Should not matter as zones are not used anyway, but it is not according to specification. – Auxin

For those who, like me, arrived here and asked "wait, what is a zone", here is the Apple Developer doc page for "zone". Zones are deprecated and hardly used at all anymore in Objective C (maybe not at all by the time you read this), but they remain as parameters for compatibility reasons. – Functional

To create the actual copy, use [instance copy]. That wasn't obvious from the answer for me... – Sadonia

got a error : No visible @interface for 'NSObject' declares the selector 'copyWithZone:' – Bearberry

Answer 2

Apple documentation says

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.

to add to the existing answer

@interface YourClass : NSObject <NSCopying> 
{
   SomeOtherObject *obj;
}

// In the implementation
-(id)copyWithZone:(NSZone *)zone
{
  YourClass *another = [super copyWithZone:zone];
  another.obj = [obj copyWithZone: zone];

  return another;
}

Tutelage

Since YourClass descends directly from NSObject I don't think it's necessary here – Stillness

Good point, but its a general rule, in case its a long class hierarchy. – Tutelage

I got an error: No visible @interface for 'NSObject' declares the selector 'copyWithZone:'. I guess this is only required when we are inheriting from some other custom class that implements copyWithZone – Refill

another.obj = [[obj copyWithZone: zone]autorelease]; for all subclasses of NSObject. And for primitive datatypes you just assign them -> another.someBOOL = self.someBOOL; – Annulate

@Refill "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." developer.apple.com/documentation/objectivec/nsobject/… – Cahill

Answer 3

I don't know the difference between that code and mine, but I have problems with that solution, so I read a little bit more and found that we have to set the object before return it. I mean something like:

#import <Foundation/Foundation.h>

@interface YourObject : NSObject <NSCopying>

@property (strong, nonatomic) NSString *name;
@property (strong, nonatomic) NSString *line;
@property (strong, nonatomic) NSMutableString *tags;
@property (strong, nonatomic) NSString *htmlSource;
@property (strong, nonatomic) NSMutableString *obj;

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

@end


@implementation YourObject


-(id) copyWithZone: (NSZone *) zone
{
    YourObject *copy = [[YourObject allocWithZone: zone] init];

    [copy setNombre: self.name];
    [copy setLinea: self.line];
    [copy setTags: self.tags];
    [copy setHtmlSource: self.htmlSource];

    return copy;
}

I added this answer because I have a lot of problems with this issue and I have no clue about why is it happening. I don't know the difference, but it's working for me and maybe it can be useful for others too : )

Marlin

Answer 4

another.obj = [obj copyWithZone: zone];

I think, that this line causes memory leak, because you access to obj through property which is (I assume) declared as retain. So, retain count will be increased by property and copyWithZone.

I believe it should be:

another.obj = [[obj copyWithZone: zone] autorelease];

or:

SomeOtherObject *temp = [obj copyWithZone: zone];
another.obj = temp;
[temp release]; 

Lobectomy

Nope, methods alloc, copy, mutableCopy, new should return non-autoreleased objects. – Abate

@kovpas, are You sure, that You understand me right? I'm not talking about returned object, I'm talking about it's data fields. – Lobectomy

yeah, my bad, sorry. could you please edit your answer somehow so I could remove minus? :)) – Abate

Answer 5

There is also the use of the -> operator for copying. For Example:

-(id)copyWithZone:(NSZone*)zone
{
    MYClass* copy = [MYClass new];
    copy->_property1 = self->_property1;
    ...
    copy->_propertyN = self->_propertyN;
    return copy;
}

The reasoning here is the resulting copied object should reflect the state of the original object. The "." operator could introduce side effects as this one calls getters which in turn may contain logic.

Scofflaw

Answer 6

Has it's limitations: works almost only with NS-friendly properties, a class must have @objcMembers

public protocol NSObjectCopier {
    func makeCopy<T: NSObject>(of source: T) -> T
}

struct StandartNSObjectCopier: NSObjectCopier {

    func makeCopy<T>(of source: T) -> T where T : NSObject {

        var copy = T.init()
        var numOfProperties: UInt32 = 0
        let properties = class_copyPropertyList(T.self, &numOfProperties)

        for i in 0..<numOfProperties {
            let idx = Int(i)
            let prop = properties![idx]
            let rawAttrs = String(cString: property_getAttributes(prop)!)
            let attrs = Set(rawAttrs.components(separatedBy: ","))
            if attrs.contains("R") {
                //skip readonly
                continue
            }
            let nsKey = NSString(utf8String: property_getName(prop))!
            let key = nsKey as String
            let srcValue = source.value(forKey: key)
            copy.setValue(srcValue, forKey: key)
        }

        return copy
    }

}

Wilkinson

Answer 7

This is probably unpopular way. But here how I do it:

object1 = // object to copy

YourClass *object2 = [[YourClass alloc] init];
object2.property1 = object1.property1;
object2.property2 = object1.property2;
..
etc.

Quite simple and straight forward. :P

Listerism