Como copiar um objeto em Objective-C

Preciso copiar em profundidade um objeto personalizado que possui objetos próprios. Tenho lido por aí e estou um pouco confuso sobre como herdar NSCopying e como usar NSCopyObject.

Como sempre com os tipos de referência, existem duas noções de "cópia". Tenho certeza que você os conhece, mas para a integridade.

1. Uma cópia bit a bit. Nesse caso, apenas copiamos o bit de memória por bit - isso é o que NSCopyObject faz. Quase sempre, não é o que você deseja. Os objetos têm estado interno, outros objetos, etc, e geralmente fazem suposições de que são os únicos que mantêm referências a esses dados. As cópias bit a bit quebram essa suposição.
2. Uma cópia profunda e lógica. Nesse caso, fazemos uma cópia do objeto, mas sem realmente fazê-lo aos poucos - queremos um objeto que se comporte da mesma forma para todos os efeitos, mas não seja (necessariamente) um clone idêntico à memória do original - o manual do Objective C chama esse objeto de "funcionalmente independente" de seu original. Como os mecanismos para fazer essas cópias "inteligentes" variam de classe para classe, pedimos aos próprios objetos que as realizem. Este é o protocolo NSCopy.

Você quer o último. Se este for um de seus próprios objetos, você precisa simplesmente adotar o protocolo NSCopying e implementar - (id) copyWithZone: (NSZone *) zone. Você é livre para fazer o que quiser; embora a ideia seja fazer uma cópia real de si mesmo e devolvê-la. Você chama copyWithZone em todos os seus campos para fazer uma cópia em profundidade. Um exemplo simples é

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

A documentação da Apple diz

Uma versão de subclasse do método copyWithZone: deve enviar a mensagem para super primeiro, para incorporar sua implementação, a menos que a subclasse desça diretamente de NSObject.

para adicionar à resposta existente

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

Não sei a diferença entre esse código e o meu, mas tenho problemas com essa solução, então li um pouco mais e descobri que temos que definir o objeto antes de devolvê-lo. Quero dizer algo como:

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

Eu adicionei essa resposta porque tenho muitos problemas com esse problema e não tenho ideia do por que isso está acontecendo. Não sei a diferença, mas está funcionando para mim e talvez possa ser útil para os outros também:)

another.obj = [obj copyWithZone: zone];

Eu acho que essa linha causa vazamento de memória, porque você acessa objatravés da propriedade que é (presumo) declarada como retain. Portanto, a contagem retida será aumentada por propriedade e copyWithZone.

Eu acredito que deveria ser:

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

ou:

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

Também existe o uso do operador -> para copiar. Por exemplo:

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

O raciocínio aqui é que o objeto copiado resultante deve refletir o estado do objeto original. O "." operador pode introduzir efeitos colaterais, pois este chama getters que, por sua vez, podem conter lógica.