Свойство NSString: скопировать или сохранить?

Допустим, у меня есть класс SomeClassс stringименем свойства:

@interface SomeClass : NSObject
{
    NSString* name;
}

@property (nonatomic, retain) NSString* name;

@end

Я понимаю, что имя может быть присвоено, и NSMutableStringв этом случае это может привести к ошибочному поведению.

• Для строк в целом всегда полезно использовать copyатрибут вместо retain?
• Является ли «скопированное» свойство каким-либо образом менее эффективным, чем такое «сохраняемое» свойство?

Для атрибутов, тип которых является классом неизменяемых значений, который соответствует NSCopyingпротоколу, вы почти всегда должны указывать copyв своем @propertyобъявлении. В retainтакой ситуации вы почти никогда не хотите указывать.

Вот почему вы хотите это сделать:

NSMutableString *someName = [NSMutableString stringWithString:@"Chris"];

Person *p = [[[Person alloc] init] autorelease];
p.name = someName;

[someName setString:@"Debajit"];

Текущее значение Person.nameсвойства будет отличаться в зависимости от того, объявлено ли свойство retainили copy- будет, @"Debajit"если свойство помечено retain, но @"Chris"если свойство помечено copy.

Поскольку почти во всех случаях вы хотите предотвратить изменение атрибутов объекта за его спиной, вы должны пометить свойства, представляющие их copy. (И если вы пишете установщик самостоятельно, а не используете, @synthesizeвы должны помнить, что нужно использовать copyвместо retainнего).

Копия должна использоваться для NSString. Если он изменчив, он копируется. Если это не так, то это просто сохраняется. Именно семантика, которую вы хотите в приложении (пусть тип делает то, что лучше).

Для строк в целом всегда полезно использовать атрибут copy вместо retain?

Да, вообще всегда используйте атрибут копирования.

Это связано с тем, что вашему свойству NSString можно передать экземпляр NSString или экземпляр NSMutableString , и поэтому мы не можем реально определить, является ли передаваемое значение неизменным или изменяемым объектом.

Является ли «скопированное» свойство каким-либо образом менее эффективным, чем такое «сохраняемое» свойство?

• Если вашему свойству передается экземпляр NSString , ответ « Нет » - копирование не менее эффективно, чем сохранение.
  (Это не менее эффективно, потому что NSString достаточно умен, чтобы фактически не выполнять копирование.)

• Если вашему свойству передается экземпляр NSMutableString, тогда ответ « Да » - копирование менее эффективно, чем сохранение.
  (Это менее эффективно, потому что фактическое выделение памяти и копирование должны произойти, но это, вероятно, желательно.)

• Вообще говоря, «скопированное» свойство потенциально может быть менее эффективным - однако, используя NSCopyingпротокол, можно реализовать класс, который «столь же эффективен» для копирования, как и для сохранения. NSString экземпляры являются примером этого.

Вообще (не только для NSString), когда я должен использовать «copy» вместо «retain»?

Вы должны всегда использовать, copyкогда вы не хотите, чтобы внутреннее состояние свойства изменялось без предупреждения. Даже для неизменяемых объектов - правильно написанные неизменяемые объекты будут эффективно обрабатывать копии (см. Следующий раздел об неизменяемости и NSCopying).

У retainобъектов могут быть причины производительности , но это связано с накладными расходами на обслуживание - вы должны управлять возможностью изменения внутреннего состояния вне вашего кода. Как говорится - оптимизируй последний.

Но я написал свой класс, чтобы он был неизменным - могу ли я просто «сохранить» его?

Нет - использовать copy. Если ваш класс действительно неизменяемый, то лучше всего реализовать NSCopyingпротокол, чтобы он возвращал сам класс при copyиспользовании. Если вы делаете это:

• Другие пользователи вашего класса получат преимущества производительности, когда они используют copy.
• copyАннотаций делает свой собственный код более ремонтопригодны - copyаннотацию указывает на то, что вы действительно не нужно беспокоиться об этом объекте меняющегося состояния в другом месте.

Я стараюсь следовать этому простому правилу:

• Хочу ли я сохранить значение объекта в тот момент, когда я присваиваю его свойству? Используйте копию .

• Хочу ли я удерживать объект, и мне все равно, каковы его внутренние значения в настоящее время или будут ли они в будущем? Используйте сильный (сохранить).

Чтобы проиллюстрировать: хочу ли я удержать имя «Лиза Миллер» ( копия ) или я хочу удержать человека, Лиза Миллер ( сильная )? Позже ее имя может измениться на «Лиза Смит», но она все равно останется тем же человеком.

С помощью этого примера можно объяснить, как скопировать и сохранить, например:

NSMutableString *someName = [NSMutableString stringWithString:@"Chris"];

Person *p = [[[Person alloc] init] autorelease];
p.name = someName;

[someName setString:@"Debajit"];

если свойство имеет тип copy, то

новая [Person name]строка будет создана для строки, которая будет содержать содержимое someNameстроки. Теперь любая операция со someNameстрокой не будет влиять на [Person name].

[Person name]и someNameстроки будут иметь разные адреса памяти.

Но в случае сохранения,

оба [Person name]будут иметь тот же адрес памяти, что и строка соменам, просто число сохраненных строк соменам будет увеличено на 1.

Таким образом, любое изменение в строке somename будет отражено в [Person name]строке.

Безусловно, добавление «copy» к объявлению свойства противоречит использованию объектно-ориентированной среды, в которой объекты в куче передаются по ссылке - одно из преимуществ, которые вы получаете, заключается в том, что при изменении объекта все ссылки на этот объект увидеть последние изменения. Многие языки предоставляют «ref» или подобные ключевые слова, чтобы позволить типам значений (то есть структурам в стеке) получить выгоду от того же поведения. Лично я бы использовал копирование экономно, и если бы я чувствовал, что значение свойства должно быть защищено от изменений, внесенных в объект, которому он был назначен, я мог бы вызвать метод копирования этого объекта во время назначения, например:

p.name = [someName copy];

Конечно, при разработке объекта, содержащего это свойство, только вы будете знать, выиграет ли дизайн от шаблона, в котором назначения получают копии - Cocoawithlove.com может сказать следующее:

«Вы должны использовать средство доступа к копии, когда параметр setter может быть изменяемым, но вы не можете изменить внутреннее состояние свойства без предупреждения », поэтому решение о том, можете ли вы выдержать неожиданное изменение значения, принадлежит вам. Представьте себе этот сценарий:

//person object has details of an individual you're assigning to a contact list.

Contact *contact = [[[Contact alloc] init] autorelease];
contact.name = person.name;

//person changes name
[[person name] setString:@"new name"];
//now both person.name and contact.name are in sync.

В этом случае, без использования копирования, наш контактный объект автоматически принимает новое значение; однако, если бы мы его использовали, нам бы пришлось вручную убедиться, что изменения были обнаружены и синхронизированы. В этом случае сохранение семантики может быть желательным; в другом случае копия может быть более подходящей.

@interface TTItem : NSObject    
@property (nonatomic, copy) NSString *name;
@end

{
    TTItem *item = [[TTItem alloc] init];    
    NSString *test1 = [NSString stringWithFormat:@"%d / %@", 1, @"Go go go"];  
    item.name = test1;  
    NSLog(@"-item.name: point = %p, content = %@; test1 = %p", item.name, item.name, test1);  
    test1 = [NSString stringWithFormat:@"%d / %@", 2, @"Back back back"];  
    NSLog(@"+item.name: point = %p, content = %@, test1 = %p", item.name, item.name, test1);
}

Log:  
    -item.name: point = 0x9a805a0, content = 1 / Go go go; test1 = 0x9a805a0  
    +item.name: point = 0x9a805a0, content = 1 / Go go go, test1 = 0x9a84660

Вы должны использовать copy все время, чтобы объявить свойство NSString

@property (nonatomic, copy) NSString* name;

Вы должны прочитать их для получения дополнительной информации о том, возвращает ли она неизменяемую строку (в случае, если изменяемая строка была передана) или возвращает сохраненную строку (в случае, если неизменная строка была передана)

NSCopying Protocol Reference

Реализовать NSCopying, сохранив оригинал вместо создания новой копии, когда класс и его содержимое неизменны

Объекты значения

Итак, для нашей неизменной версии мы можем просто сделать это:

- (id)copyWithZone:(NSZone *)zone
{
    return self;
}

Поскольку имя является (неизменяемым) NSString, копировать или сохранять не имеет значения, если вы установите другое NSStringимя. Другими словами, копирование ведет себя как сохранение, увеличивая количество ссылок на единицу. Я думаю, что это автоматическая оптимизация для неизменяемых классов, поскольку они неизменяемы и не требуют клонирования. Но когда NSMutalbeString mstrдля имени установлено имя, содержимое mstrбудет скопировано во имя правильности.

Если строка очень большая, то копирование повлияет на производительность, и две копии большой строки будут использовать больше памяти.